leetcode 174 周賽題解

1337. 方陣中戰鬥力最弱的 K 行

題意：

返回二維數組，每行1的個數的排序。

代碼:

python

class Solution:
    def kWeakestRows(self, mat, k) :
        ans = [[sum(line), i] for i , line in enumerate(mat)]
        ans.sort(key = lambda  x:x[0])
        return [ans[i][1] for i in range(k)]

c++

class Solution {
public:
    vector<int> kWeakestRows(vector<vector<int>>& mat, int k) {
        vector<int> vec;
        for(int i=0;i<mat.size();i++){
            int tmp = 0;
            for(int num: mat[i]){
               if(num == 1) tmp+=1;
            }
            vec.push_back({tmp,i});
        }
        sort(vec.begin(),vec.end());
        vector<int> ans;
        for(int i=0;i<k;i++){
            ans.push_back(vec[i][1]);
        }
        return ans;
    }
};

c++裏，默認對二維的vector進行sort是對其鍵值排序。

1338. 數組大小減半

題意：

代碼：

class Solution:
    def minSetSize(self, arr: List[int]) -> int:
        import collections
        count = collections.Counter(arr)
        order = sorted(count, key = lambda x:count[x], reverse = True)
        print(order)
        all , ans, sum = len(arr), 0, 0 
        for num in order:
            sum += count[num]
            ans +=1
            if sum * 2 >= all:
                return ans

class Solution {
    public:
        int minSetSize(vector<int>& arr) {
            int num[100005];
            memset(num,0,sizeof(num));
            for(int c : arr){
                num[c]+=1;
            }
            sort(num, num+100005, greater<int>());
            int all = arr.size(), sum=0, ans=0;
            for(int i=0;i<1e5+1;i++){
                sum += num[i];
                if(sum*2>= all){
                    ans = i+1;
                    break;
                }
            }
            return ans;
        }
};

1339. 分裂二叉樹的最大乘積

題意：

在一棵二叉樹裏,每個節點有一個數值，隨意的刪除一條邊，使分裂的二叉樹的乘積儘可能大。

思路：

樹型搜索的題目，一遍dfs遍歷二叉樹，保存以每個節點爲根子樹的和。 然後枚舉刪除整個樹和這個子樹之間的邊進行判斷。

代碼：

class Solution:
    def dfs(self, root):
        self.num[root]  = root.val
        if root.left != None : self.num[root] += self.dfs(root.left)
        if root.right != None: self.num[root] += self.dfs(root.right)
        return self.num[root]

    def maxProduct(self, root) :
        self.num = {}
        self.dfs(root)
        ans, all = 0, self.num[root]
        for node in self.num:
            ans = max(ans , (all - self.num[node]) *self.num[node])
        return int(ans % (1e9+7))

跳躍遊戲 V

思路：

典型動態規劃,我們遍歷每個點的順序 從矮到高遍歷，然後記錄每個點的可移動的最大步數。

這樣就可以得到的動態轉移方程爲:

dp[i] = max(dp[可以去的階梯])+1;

代碼 :

class Solution:
    def maxJumps(self, arr: List[int], d: int) -> int:
        n = len(arr)
        dp = [1] * n
        tmp = [(arr[i], i) for i in range(n)]
        tmp = sorted(tmp)
        for i in range(n):
            height = tmp[i][0]
            index = tmp[i][1]
            l = index -1
            while l>=0 and index -l<=d and arr[l]<arr[index]:
                dp[index] = max(dp[index] , dp[l]+1)
                l-=1
                
            r = index + 1
            while r< n and r-index <=d and arr[r]<arr[index]:
                dp[index] = max(dp[index] , dp[r]+1)
                r+=1
        return max(dp)

class Solution {
public:
	int maxJumps(vector<int>& arr, int d) {
		int n = arr.size();
		vector<vector<int>> temp;
		vector<int> dp(n, 0);
		int res = 1;
		for (int i = 0; i < arr.size(); i++)
			temp.push_back({ arr[i],i });
		sort(temp.begin(), temp.end());

		for (int i = 0; i < n; i++) {
			int index = temp[i][1]; //編號;
			dp[index] = 1;
			//向左找
			for (int j = index - 1; j >= index - d && j >= 0; j--) {
				if (arr[j] >= arr[index]) break;
				if (dp[j] != 0) dp[index] = max(dp[index], dp[j ] + 1);
			}
			//向右找
			for (int j = index + 1; j <= index + d && j < n; j++) {
				if (arr[j] >= arr[index]) break;
				if (dp[j] != 0) dp[index] = max(dp[index], dp[j] + 1);
			}
			res = max(dp[index], res);
		}
		return res;

	}
};