2022-12-04 第 322 场周赛

6253. 回环句

class Solution {
    public boolean isCircularSentence(String sentence) {
        int n = sentence.length();
        if (sentence.charAt(0) != sentence.charAt(n-1)) {
            return false;
        }
        String[] str = sentence.split(" ");
        char pre = str[0].charAt(0);
        for (String s : str) {
            if (s.charAt(0) != pre) {
                return false;
            }
            int len = s.length();
            pre = s.charAt(len-1);
        }
        return true;
    }
}

6254. 划分技能点相等的团队

class Solution {
    public long dividePlayers(int[] skill) {
        Arrays.sort(skill);
        int n = skill.length;
        long ans = 0;
        int sum = skill[0] + skill[n-1];
        for (int i = 0; i < n/2; i++) {
            if (sum != skill[i] + skill[n-i-1]) {
                return -1;
            }
            ans += skill[i] * skill[n-i-1];
        }
        return ans;
    }
}

6255. 两个城市间路径的最小分数

并查集 构建并查集，然后找出和1或n相连接的最短边。
最开始想到的是BFS，但不清楚为什么出错了。

class Solution {
    public int minScore(int n, int[][] roads) {
        int[] parents = new int[n+1];
        for (int i = 1; i <= n; i++) {
            parents[i] = i;
        }
        int min = Integer.MAX_VALUE;
        for (int[] arr : roads) {
            union(parents,arr[0],arr[1]);
        }
        int target = find(parents,1);
        for (int[] arr: roads) {
            if (target == find(parents,arr[0])) {
                min = Math.min(min,arr[2]);
            }
        }
        return min;
    }
    
    public void union(int[] parents, int a, int b) {
        int ai = find(parents,a);
        int bi = find(parents,b);
        parents[ai] = bi;
        parents[a] = bi;
    }
    public int find(int[] parents, int x) {
        if (parents[x] != x) {
            parents[x] = find(parents,parents[x]);
            return parents[x];
        }
        return x;
    }
//     class edge {
//         int a;
//         int b;
//         int d;
//         edge(int a, int b, int d) {
//             this.a = a;
//             this.b = b;
//             this.d = d;
//         }
//     }
//     public int minScore(int n, int[][] roads) {
        
//         List<edge>[] arr = new List[n+1];
//         for (int i = 0; i <= n; i++) {
//             arr[i] = new ArrayList<>();
//         }
//         for (int[] road : roads) {
//             edge e1 = new edge(road[0],road[1],road[2]);
//             edge e2 = new edge(road[1],road[0],road[2]);
//             arr[road[0]].add(e1);
//             arr[road[1]].add(e2);
//         }
//         int a1 = bfs(arr,new boolean[n+1],1);
//         int a2 = bfs(arr,new boolean[n+1],n);
//         return Math.min(a1,a2);
//     }
    
//     public int bfs(List<edge>[] arr, boolean[] visited, int src) {
//         Queue<Integer> queue = new LinkedList<>();
//         queue.offer(src);
//         int min = Integer.MAX_VALUE;
//         visited[src] = true;
//         while (!queue.isEmpty()) {
//             int size = queue.size();
//             for (int i = 0; i < size; i++) {
//                 int tmp = queue.poll();
//                 List<edge> list = arr[tmp];
//                 for (edge e : list) {
//                     if (visited[e.b]) {
//                         continue;
//                     }
//                     min = Math.min(min,e.d);
//                     queue.offer(e.b);
//                     visited[e.b] = true;
//                 }
//             }
//         }
//         return min;
//     }
}