*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;}