LeetCode Weekly Contest 85 题解+总结(模拟，概率dp，dfs)

最新推荐文章于 2022-06-23 06:41:39 发布

原创最新推荐文章于 2022-06-23 06:41:39 发布 · 846 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #dp #dfs #暴力

算法&数据结构专栏收录该内容

227 篇文章

订阅专栏

本文分享了四道LeetCode题目（RectangleOverlap、PushDominoes、New21Game、SimilarStringGroups）的解题思路及Java代码实现，涵盖模拟、DP、图论等算法。通过实际案例介绍了如何高效解决这些问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这次题目依旧很简单，很遗憾没能AK，立个 flag

连续AK一个月后不再打LC

题目依旧是模拟+ 简单dp+hard是一个图论基础

836. Rectangle Overlap（easy）
- java code
838. Push Dominoes（模拟，easy）
- 技巧总结
- java code
837. New 21 Game(概率dp，medium)
- java code
839. Similar String Groups(暴力+dfs)
- java code

题目链接

836. Rectangle Overlap（easy）

矩形求交

java code

class Solution {
    public boolean isRectangleOverlap(int[] rec1, int[] rec2) {
        int minx = Math.max(rec1[0], rec2[0]);
        int miny = Math.max(rec1[1], rec2[1]);
        int maxx = Math.min(rec1[2], rec2[2]);
        int maxy = Math.min(rec1[3], rec2[3]);
        return minx < maxx && miny < maxy;
    }
}

838. Push Dominoes（模拟，easy）

简单模拟

技巧总结

模拟题算法想好再敲
加”哨兵”是个好主意

java code

class Solution {

    public String pushDominoes(String dominoes) {
        dominoes = 'L'+dominoes+'R';
        char[] ret = new char[dominoes.length()];
        Arrays.fill(ret, '.');
        ArrayList<Integer> flag = new ArrayList<>();
        for(int i=0 ; i<dominoes.length() ;++i){
            if(dominoes.charAt(i)!='.')flag.add(i);
        }
        for(int i=1; i<flag.size()-1;  ++i){
            if(dominoes.charAt(flag.get(i))=='L'){
                int prev = flag.get(i-1);
                int end = prev+1;
                if(dominoes.charAt(prev)=='R'){
                    end = (prev+flag.get(i))/2+1;
                }
                for(int j= flag.get(i) ; j>=end ; --j)
                    ret[j] = 'L';
            }else {
                int next = flag.get(i+1);
                int end =next-1;
                if(dominoes.charAt(next) == 'L')
                    end = (end + flag.get(i))/2;
                for(int j=flag.get(i) ; j<= end ; ++j)
                    ret[j] = 'R';
            }
        }
        return String.valueOf(ret,1,ret.length-2);
    }
}

837. New 21 Game(概率dp，medium)

概率dp，还是很简单，坑的是数据开始给错了。

计算一个滑动前缀和

java code

class Solution {
    public double new21Game(int N, int K, int W) {
        if(K<=0)return 1.0;
        double ret =0;
        double[] dp = new double[N+5];
        double[] sum = new double[N+5];
        dp[0] =1;
        sum[0] =0;
        sum[1] = 1.0;
        for(int i=1 ; i<=N ; ++i){
            int last = Math.min(K, i);
            int prev = Math.max(0, i-W);
            dp[i] = (sum[last] - sum[prev])/W;
            sum[i+1] = sum[i]+dp[i];
            if(i>=K)ret+=dp[i];
        }
        return ret;
    }
}

839. Similar String Groups(暴力+dfs)

这题比较字符串竟然使用暴力，超出对我的认知，其实不难，就是求无向图连通分量数，不过加了个暴力比较字符串而已

time $O(n^2W)$

java code

class Solution {
    int n;
    boolean[] vis;
    ArrayList<Integer>[] G;
    @SuppressWarnings("unchecked")
    public void init(String[] A) {
        n = A.length;
        G = new ArrayList[n];
        vis = new boolean[n];
        Arrays.fill(vis, false);
        for(int i=0 ; i<n ; ++i)
            G[i] = new ArrayList<>();
    }
    private boolean isGroup(String s1,String s2) {
        ArrayList<Integer> diff = new ArrayList<>();
        for(int i=0 ; i<s1.length() ; ++i)
            if(s1.charAt(i) != s2.charAt(i))diff.add(i);
        if(diff.size() ==2){
            return s1.charAt(diff.get(0)) == s2.charAt(diff.get(1)) && 
                    s1.charAt(diff.get(1))==s2.charAt(diff.get(0));
        }
        return false;
    }
    private void dfs(int v) {
        vis[v] = true;
        for(Integer e: G[v])
            if(!vis[e])dfs(e);
    }
    public int numSimilarGroups(String[] A) {
        int ret =0;
        init(A);
        for(int i=0 ; i<n ; ++i){
            for(int j=i+1 ; j<n ; ++j){
                if(isGroup(A[i], A[j])){
                    G[i].add(j);
                    G[j].add(i);
                }
            }
        }
        for(int i=0 ; i<n ; ++i){
            if(!vis[i]){
                ++ret;
                dfs(i);
            }
        }
        return ret;
    }
}