Java Backtracking Algorithms: Sudoku, Knapsack, and Tasks

Sudoku Solver Implementation

private boolean isValid(int r, int c, int n) {
  boolean valid = true;
  int sr, sc, fr, fc;
  for (int i = 0; i < 9 && valid; i++) {
    if (i != r) if (grid[i][c] == n) valid = false;
    if (i != c) if (grid[r][i] == n) valid = false;
  }
  if (valid) {
    sr = (r / 3) * 3; fr = sr + 3; sc = (c / 3) * 3; fc = sc + 3;
    for (int i = sr; i < fr && valid; i++) {
      for (int j = sc; j < fc && valid; j++) {
        if (grid[i][j] == n) valid = false;
      }
    }
  }
  return valid;
}

private boolean solveRec(int row, int col) {
  boolean solved = false;
  if (row == 9) solved = true;
  else {
    if (grid[row][col] == 0) {
      for (int i = 1; i < 10; i++) {
        if (isValid(row, col, i)) {
          grid[row][col] = i;
          solved = solveRec(col == 8 ? row + 1 : row, (col + 1) % 9);
          if (!solved) grid[row][col] = 0;
        }
      }
    } else {
      solved = solveRec(col == 8 ? row + 1 : row, (col + 1) % 9);
    }
  }
  return solved;
}

0/1 Knapsack Problem

public Knapsack01(double[] wi, double[] pi, double we) {
  optP = 0; w = wi; p = pi; maxW = we;
  nItems = w.length; optX = new int[nItems];
  x = new int[nItems];
  for (int i = 0; i < nItems; i++) x[i] = 0;
}

public void knapsack() { knapsack(0, 0.0); }

public int[] getSol() { return optX; }

public void knapsack(int l, double cW) {
  if (l == nItems) {
    double aux = 0.0;
    for (int i = 0; i < l; i++) aux += p[i] * x[i];
    if (aux > optP) {
      for (int i = 0; i < nItems; i++) optX[i] = x[i];
      optP = aux;
    }
  } else {
    if (cW + w[l] <= maxW) {
      x[l] = 1;
      knapsack(l + 1, cW + w[l]);
    }
    x[l] = 0;
    knapsack(l + 1, cW);
  }
}

Task Distribution Algorithm

public void taskDistribution(int level, int[] actual) {
  if (level == nTasks) {
    double prof = profit(actual);
    if (prof > maxProfit) {
      maxProfit = prof;
      for (int i = 0; i < nTasks; i++) solution[i] = actual[i];
    }
  } else {
    for (int i = 0; i < nTasks; i++) {
      if (valid(actual, level, i)) {
        actual[level] = i;
        taskDistribution(level + 1, actual);
      }
    }
  }
}