*Leetcode 368. Largest Divisible Subset

https://leetcode.com/problems/largest-divisible-subset/

好久不刷题，后果是，边界考虑，以及代码速度细节都很差

想到的最好的做法O(n^2):

class Solution {
public:
    vector<int> largestDivisibleSubset(vector<int>& nums) {
        vector<int> ans;
        if(nums.size() == 0)return ans;
        sort(nums.begin(), nums.end());
        int path[nums.size()];
        int dp[nums.size()], max_pos = 0, max_cnt = 0;
        for(int i = 0; i < nums.size(); i++) {
            dp[i] = 1;
            path[i] = i;
            for(int j = 0; j < i; j++) {
                if( nums[i]%nums[j] == 0 && dp[j] + 1 > dp[i]){
                    dp[i] = dp[j] + 1;
                    path[i] = j;
                    if (dp[i] > max_cnt) {
                        max_cnt = dp[i];
                        max_pos = i;
                    }
                } 
            }
        }
        
        while(1) {
            ans.push_back(nums[max_pos]);
            if(max_pos == path[max_pos]) {
                break;
            }
            max_pos = path[max_pos];
            
        }
        sort(ans.begin(), ans.end());
        
        return ans;
    }
};

其他做法：

最暴力的不用说了，枚举所有子集，肯定超时。信息检索有一个算法是布尔查询，也就是词项-文档集合。http://blog.csdn.net/qll125596718/article/details/8437670  这里有讲解。那么把a与b的整除关系作为一个类似的词项-文档矩阵，若干行取与，是可以计算出来结果的 O(n^3)次方，只是当时自己这个想法有点意思，所以记录下来：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int SIZE = 1000+1;
int mat[SIZE][SIZE];

void show_mat(int n) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			printf("%3d ", mat[i][j]);
		}
		putchar('\n');
	}
}

int main() {
	int nums[] = {2,3,6,7,10,12};
	int len = sizeof(nums)/4;



	memset(mat, 0, sizeof(mat));
	for (int i = 0; i < len; i++) {
		for (int j = 0; j < len; j++) {
			if (nums[i] % nums[j] == 0 || nums[j] % nums[i] == 0) {
				mat[i][j] = 1;
			}
		}
	}

	show_mat(len);

	int max_pos = -1, max_cnt = 0;

	for (int i = 0; i < len; i++) {
		//第i个数要不要
		int result[len], first = 0;
		for (int j = 0; j < len; j++) {
			if (mat[j][i] != 1) continue;
			if (first == 0) {
				first = 1;
				for (int k = 0; k < len; k++) {
					result[k] = mat[j][k];
				}
				continue;
			}
			for (int k = 0; k < len; k++) {

				result[k] &= mat[j][k];
				
			}
		}
		int cnt = 0;
		for (int k = 0; k < len; k++) {
			if (result[k]) {
				cnt ++;
			}
		}
		if (cnt > max_cnt) {
			max_cnt = cnt;
			max_pos = i;
		}
	}

	cout << "max cnt:" << max_cnt << endl;
	int i = max_pos;
	int result[len], first = 0;
		for (int j = 0; j < len; j++) {
			if (mat[j][i] != 1) continue;
			if (first == 0) {
				first = 1;
				for (int k = 0; k < len; k++) {
					result[k] = mat[j][k];
				}
				continue;
			}
			for (int k = 0; k < len; k++) {

				result[k] &= mat[j][k];
				
			}
		}
	for (int i = 0; i < len; i++) {
		if (result[i]) {
			printf("%3d ", nums[i]);
		}
	}

	return 0;
}

最初想得dp和最优解的方程一样，但是有一个地方，就是递推的时候，一个数加入原来的集合，是不是要遍历原来的集合保证这个数跟其他的数都有整除关系才行？

实际是只要先排序，新加入的数大于旧的集合的最大的数，所以只需要判断一次就行。下面是老的代码，就是没考虑到这点的时候的代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int SIZE = 1000+1;


int dp[SIZE];
int ans[SIZE][SIZE];

int legal(int a, int b) {
	return a%b == 0 || b%a == 0;
}

void solve(int nums[], int n) {
	dp[0] = 1;
	ans[0][0] = 1;
	for (int i = 1; i < n; i++) {
		dp[i] = 1;
		int max_cnt = 1, pos = i, flag = 1, cnt;
		for (int j = 0; j < i; j++) {
			flag = 1;
			if ( legal(nums[i], nums[j]) ) {
				for (int k = 0; k < j; k++) {
						if (!ans[j][k])continue;
						if (!legal(nums[k], nums[i])) {
							flag = 0;
							break;
						} 
				}

				if (!flag) {
					break;
				}

				if (dp[j] + 1 > max_cnt) {
					pos = j;
					max_cnt = dp[j] + 1;
				}
			} 
		}
		if (max_cnt >= dp[i]) {
			dp [i] = max_cnt;
			ans[i][i] = 1;
			for (int j = 0; j < i; j++) {
				ans[i][j] = pos == i ? 0 : ans[pos][j];
			}
		}
	}
	int cnt = 0, pos = 0;
	for (int i = 0; i < n; i++) {
		if(dp[i] > cnt) {
			cnt = dp[i];
			pos = i;
		}
		cout <<  "i:" << i << " dp:" << dp[i] << endl;
	}

	cout << "max cnt:" << cnt << endl;
	for (int i = 0; i <=pos; i++) {
		if (ans[pos][i]) {
			printf("%d ", nums[ i ]);
		}
	}
}

int main() {
	int nums[] = {2,3,6,7,10,12};
	int len = sizeof(nums)/4;

	solve(nums, len);



	return 0;
}