第一题是整数的方阵，求其中的子方阵，和最大。返回最大和以及子方阵宽度。因为做了topcoder的题，所以比较顺手，O(n^3)的复杂度。
pair<int,int> maxiSum(vector<vector<int> > &a) { //first is n second is sum
int N = a.size();
int retVal = INT_MIN;
int n = 1;
// fix two columns, i, j
for (int i = 0; i < N; i++) {
vector<int> sum(N);
for (int j = i; j < N; j++) {
// calc the sum per line
for (int k = 0; k < N; k++) {
sum[k] = sum[k] + a[k][j];
}
// calc the sum of the squere with i, j
int tmpSum = 0;
int w = j - i;
for (int m = 0; m < N; m++) {
if (m < w) {
tmpSum += sum[m];
} else if (m == w) {
tmpSum += sum[m];
if (tmpSum > retVal) {
retVal = tmpSum;
n = w + 1;
}
} else {
tmpSum += sum[m];
tmpSum -= sum[m - w - 1];
if (tmpSum > retVal) {
retVal = tmpSum;
n = w + 1;
}
}
}
}
}
return make_pair(n, retVal);
}
第二题，是有个0和1的矩阵，求里面每个位置到最近的0的距离（类似曼哈顿距离）。这个题一开始想动态规划什么的，都不合适，比较像洪泛，但如果从每个0或1出发，就效率很低，n^4和完全枚举是一样的。后来想到和之前topcoder的一道题挺像，可以先把0全部放到queue里面，然后逐步往外扩，便可求得。
void make(vector<vector<int> > &matrix) {
int N = matrix.size();
vector<vector<int> > dist;
vector<vector<bool> > visited;
dist.resize(N);
visited.resize(N);
for (int i = 0; i < N; i++) {
dist[i].resize(N);
visited[i].resize(N);
}
queue<pair<int, int> > que;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (matrix[i][j] == 0) {
dist[i][j] = 0;
visited[i][j] = true;
que.push(make_pair(i, j));
}
}
}
while (!que.empty()) {
pair<int, int> pp = que.front();
que.pop();
if (valid(pp.first - 1, pp.second, visited)) {
dist[pp.first - 1][pp.second] = dist[pp.first][pp.second] + 1;
que.push(make_pair(pp.first - 1, pp.second));
visited[][] = true;
}
if (valid(pp.first, pp.second - 1, visited)) {
}
if (valid(pp.first + 1, pp.second, visited)) {
}
if (valid(pp.first, pp.second + 1, visited)) {
}
}
// copy to matrix
matrix = dist;
}
bool valid(int i, int j, vector<vector<bool> > & visited) {
// return whether we need to process this elem
int N = visited.size();
if (i < 0 || j < 0 || i >= N || j >= N || visited[i][j]) {
return false;
}
return true;
}
遍历四个方向的代码其实应该更精简，类似如下：
dx[] = {-1,0,1,0}
dy[] = {0,1,0,-1}
x + dx[i]
y + dy[i]
第三题当时没有想出来，是求一个数组中子段和的绝对值最小值。比如如下数组，就是1+2+ -3的绝对值最小。
{1，2，－3，－100，3}
这个题目很自然会想到去用最大子段和的做法，但是（应该）不能类似动态规划降到O(n)。关键是，不满足最优子问题的特性。比如该数组中前三个元素的最优解是0，前两个元素的最优解是2，0没有用到之前最优解地方。
那么正确的做法是可以记录之前的前缀和，然后排序，就可以求得了。因为：|sum[i..j]| = |p[j] - p[i - 1]|，p是前缀和，那么排完序后，相邻的两个就能求得绝对值最小，只是要注意，i从0开始，那么p[-1]就是不包括0的情况，就是0，要在前缀和数组里加一个0.
本题的前缀和数组排序完了就是如下，里面两个0，一个开始之前p[-1]，一个p[2]，就能求出sum[0..2]=0，绝对值最小。
{-97, -94, 0, 0, 1, 3}