LeetCodeWeeklyContest-174

题目传送：第174周赛

Rank: 789 / 1659
Grade：7/18
加油！


力扣好像改版了，之前周赛结束之后，还是能进去的，现在结束之后直接进到题库了，好像也还不错哦~

1.方阵中战斗力最弱的K行

用一个结构体来保存记录，自定义排序的比较函数，签到题。

struct node{
	int index;
	int armynum;
};
bool cmp(node a,node b){
	if(a.armynum!=b.armynum)
		return a.armynum < b.armynum;
	else  return a.index < b.index; 
}
class Solution {
public:
    vector<int> kWeakestRows(vector<vector<int>>& mat, int k) {
	    int m = mat.size(),n = mat[0].size();
	    node arr[m];
        memset(arr,0,sizeof(arr));
	    for(int i=0;i<m;i++){
	 	    arr[i].index = i;
	 	    for(int j=0;j<n;j++){
	 		    if(mat[i][j]==1) arr[i].armynum ++;
		    }
	    } 
        
	    sort(arr,arr+m,cmp);
	    vector<int> res;
	    for(int i=0;i<k;i++){
		    res.push_back(arr[i].index);
	    }  
	    return res;    
    }
};

2.数组大小减半

找到最小元素个数能使集合中元素的个数减半。统计每个元素出现的个数，然后对个数递减排序，遍历个数数组，直到减半为止…

class Solution {
public:
    int minSetSize(vector<int>& arr) {
 	sort(arr.begin(),arr.end());
    int n = arr.size(),cnt = 1;
 	vector<int> res;
 	
    for(int i=1;i<n;i++){
		if(arr[i-1]!=arr[i]){
			res.push_back(cnt);
			cnt = 1;
		}
		else cnt ++;
	}
    res.push_back(cnt);
    // for(int i=0;i
    //     cout << res[i] << " ";
	sort(res.begin(),res.end(),greater<int>());
	int ans = 0,r=0;
	for(int i=0;i<res.size();i++){
		ans += res[i],r++;
		if(ans>=n/2){
			return r;
		}
	}
    return n;
 }
};

3.分裂二叉树的最大乘积

还是搜索，dfstotal函数是用来求树的和，我觉得第二个dfs函数很难想。

typedef  long long ll;
class Solution {
    ll total = 0,ans=0,mod=1e9+7;
    void  dfstotal(TreeNode *root){
        if(root==NULL) return ;
        total += root->val;
        dfstotal(root->left);
        dfstotal(root->right);
    }
    ll dfs(TreeNode* root){
        if(root==NULL) return 0;
        ll suml = dfs(root->left),sumr = dfs(root->right);
        ans = max(ans,suml*(total-suml));
        ans = max(ans,sumr*(total-sumr));
        return root->val+suml+sumr;
    }
public:
    int maxProduct(TreeNode* root) {
        dfstotal(root);
        dfs(root);
        return ans%mod;
        
    }
};

4.跳跃游戏 V

参考：dp记忆化搜索
f[i]表示从下标i出发能访问的最多元素个数，题目要求只能从高处往低处跳，中间不能有更高的，一开始理解错题意了，以为只有有一个矮的就可以了，没想到是都要比起跳点矮…所以只要有一个更高，就break。里面会涉及到很多重复计算，可以用f[i]数组来记录，也就是记忆化，如果f[i]有值，则不用再去搜索。

#define N 100050
int f[N],a[N];
int dfs(int i,int d,int n){
    if(f[i]!=-1) return f[i];
    f[i] = 1;
    for(int u=i+1;u-i<=d&&u<n;u++){
        if(a[u]>=a[i]) break;
        f[i] = max(f[i],1+dfs(u,d,n));
    }
    for(int u=i-1;u>=0&&i-u<=d;u--){
        if(a[u]>=a[i]) break;
        f[i] = max(f[i],1+dfs(u,d,n));
    }
    return f[i];   
}
class Solution {
public:
int maxJumps(vector<int>& arr, int d) {
   	int n = arr.size(),ans = 0;
    for(int i=0;i<n;i++) a[i] = arr[i];
    memset(f,-1,sizeof(f));
    for(int i=0;i<n;i++){
        ans = max(ans,dfs(i,d,n));
    }
	 return ans;
}
};