【LeetCode】第 370 场周赛

100115. 找到冠军 I

一场比赛中共有 n 支队伍，按从 0 到 n - 1 编号。

给你一个下标从 0 开始、大小为 n * n 的二维布尔矩阵 grid 。对于满足 0 <= i, j <= n - 1 且 i != j 的所有 i, j ：如果 grid[i][j] == 1，那么 i 队比 j 队 强 ；否则，j 队比 i 队 强 。

在这场比赛中，如果不存在某支强于 a 队的队伍，则认为 a 队将会是 冠军 。

返回这场比赛中将会成为冠军的队伍。

---

复杂度：O（N*N）
思路：用cnt记录每个人获胜的次数，哪名玩家的cnt更大，就将答案更新为那名玩家。

class Solution {
    public int findChampion(int[][] grid) {
        int ans = 0;
        int cnt = 0;
        int n = grid.length;
        int m = grid[0].length;
        for(int i=0; i<n; i++) {
            int c = 0;
            for(int j=0; j<n; j++) {
                if(grid[i][j] == 1) {
                    c ++;
                }
                if(c>cnt) {
                    cnt = c;
                    ans = i;
                }
            }
        }
        return ans;
    }
}

100116. 找到冠军 II

一场比赛中共有 n 支队伍，按从 0 到 n - 1 编号。每支队伍也是 有向无环图（DAG） 上的一个节点。

给你一个整数 n 和一个下标从 0 开始、长度为 m 的二维整数数组 edges 表示这个有向无环图，其中 edges[i] = [ui, vi] 表示图中存在一条从 ui 队到 vi 队的有向边。

从 a 队到 b 队的有向边意味着 a 队比 b 队 强 ，也就是 b 队比 a 队 弱 。

在这场比赛中，如果不存在某支强于 a 队的队伍，则认为 a 队将会是 冠军 。

如果这场比赛存在 唯一 一个冠军，则返回将会成为冠军的队伍。否则，返回 -1 。

注意

环 是形如 a1, a2, …, an, an+1 的一个序列，且满足：节点 a1 与节点 an+1 是同一个节点；节点 a1, a2, …, an 互不相同；对于范围 [1, n] 中的每个 i ，均存在一条从节点 ai 到节点 ai+1 的有向边。
有向无环图 是不存在任何环的有向图。

---

复杂度：O（N）
思路：统计入度，更优化的。统计每个节点的前继节点，没有记为-1。若有多个-1，则将返回-1。

class Solution {
    public int findChampion(int n, int[][] edges) {
        int ans = -1;
        
        // 保存前继节点
        int[] pre = new int[n];
        
        Arrays.fill(pre, -1);
        
        
        int m = edges.length;
        for(int i=0; i<m; i++) {
            pre[edges[i][1]] = edges[i][0];
        }
        int cnt = 0;
        for(int i=0; i<n; i++) {
            if(pre[i] == -1) {
                cnt ++;
                if(cnt == 2) {
                    return -1;
                }
                ans = i;
            }
            
        }
        
        return ans;
    }
}

100118. 在树上执行操作以后得到的最大分数

有一棵 n 个节点的无向树，节点编号为 0 到 n - 1 ，根节点编号为 0 。给你一个长度为 n - 1 的二维整数数组 edges 表示这棵树，其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 有一条边。

同时给你一个长度为 n 下标从 0 开始的整数数组 values ，其中 values[i] 表示第 i 个节点的值。

一开始你的分数为 0 ，每次操作中，你将执行：

选择节点 i 。
将 values[i] 加入你的分数。
将 values[i] 变为 0 。
如果从根节点出发，到任意叶子节点经过的路径上的节点值之和都不等于 0 ，那么我们称这棵树是 健康的 。

你可以对这棵树执行任意次操作，但要求执行完所有操作以后树是 健康的 ，请你返回你可以获得的 最大分数 。

---

复杂度：O（N）
思路：DFS。原问题可以更换为：sum-每条路径上删去一个点。自底向上，统计删除子节点和删除根节点哪个成本更少。

class Solution {
    List<Integer>[] g;
    public long maximumScoreAfterOperations(int[][] edges, int[] values) {
        long ans = 0;
        for(int v:values) {
            ans += v;
        }
        int n = values.length;
        if(n == 2) {
            return Math.max(values[0], values[1]);
        }
        g = new ArrayList[n];
        
        // 存储后继节点
        Arrays.setAll(g, e-> new ArrayList());
        
        // 是否为根节点
        int[] cnt = new int[n];
        
        
        int m = edges.length;
        for(int[] e:edges) {
            int x = Math.min(e[0], e[1]);
            int y = Math.max(e[0], e[1]);
            
            g[x].add(y);
            g[y].add(x);     
        }     

        boolean[] visibled = new boolean[n]; 
       // System.out.println(ans);
        return ans-dfs(g[0], 0, values, visibled, 0);
    }
    private long dfs(List<Integer> list, int idx, int[] values, boolean[] visibled, int l) {
        long ans = values[idx];
        int n = list.size();
        if(n == 1&&l!=0) return ans;
        l ++;
        long sum = 0;
        visibled[idx] = true;
        for(int i=0; i<n; i++) {
            // 获取后继索引
            int t = list.get(i);
            if(visibled[t] == false) {
               // System.out.println(idx+"-"+t);
                sum = sum + dfs(g[t], t, values, visibled, l);
            }            
        }
        return Math.min(sum, ans);
    }
}

100112. 平衡子序列的最大和

给你一个下标从 0 开始的整数数组 nums 。

nums 一个长度为 k 的 子序列 指的是选出 k 个 下标 i0 < i1 < … < ik-1 ，如果这个子序列满足以下条件，我们说它是 平衡的 ：

对于范围 [1, k - 1] 内的所有 j ，nums[ij] - nums[ij-1] >= ij - ij-1 都成立。
nums 长度为 1 的 子序列 是平衡的。

请你返回一个整数，表示 nums 平衡 子序列里面的 最大元素和 。

一个数组的 子序列 指的是从原数组中删除一些元素（也可能一个元素也不删除）后，剩余元素保持相对顺序得到的 非空 新数组。

---

复杂度：O(NlogN)
思路：
 ①将题目要求的条件改为num[i]-i为递增的。那么可以将num[i]-i按照从小到大的顺序离散到1-n。将nums[i]-i按照大小离散化到1-n。
 ②DP。dp[i]表示前i个元素的子序列和的最大值。
dp[i] = Math.max(dp[j])+nums[i]。j<i且nums[j]<=nums[i]
 ③使用树状数组实现dp[i]。由于nums[i]-i被按照大小离散化到1-j-n。所以只要搜寻j之前的元素即可。这部分使用preMax函数实现。
更新树状数组时，由于记录的已经是前缀和，直接按照大小更新。

class Solution {
    long minN = Long.MIN_VALUE;
    // 树状数组
    class BIT{
        // 数组
        private long[] tree;
        public BIT(int n) {
            tree = new long[n];
            Arrays.fill(tree, minN);
        }

        public void update(int i, long val) {
            while(i<tree.length) {
                tree[i] = Math.max(tree[i], val);
                i += i&-i;
            }
        }

        public long preMax(int i) {
            long res = minN;
            while(i>0) {
                res = Math.max(res, tree[i]);
                i -= i&-i;
            }
            return res;
        }

    }
    public long maxBalancedSubsequenceSum(int[] nums) {
        int n = nums.length;
        int[] b = new int[n];

        for(int i=0; i<n; i++) {
            b[i] = nums[i] - i;
        }
        long ans = minN;
        Arrays.sort(b);
        BIT tree = new BIT(n+1);
        for(int i=0; i<n; i++) {
            // 离散区间
            int j = Arrays.binarySearch(b, nums[i]-i)+1;
            long f = Math.max(tree.preMax(j), 0) + nums[i];
            ans = Math.max(ans, f);
            tree.update(j, f);
        }
    
        return ans;
    }
}