20210805力扣字符串类题做题汇总

---

每日一题611：判断是否是三角形

我的固有印象就是使用暴力去解，然后就超时了，然后对这个数组排序后重新计算，算是通过了，但是用的时间太长了。

class Solution {
    public int triangleNumber(int[] nums) {
        int n = nums.length;
        if(n<3) return 0;
        int count = 0;
        Arrays.sort(nums);
        for(int i = 0 ;i<n-2;i++)
        {
            for(int j=i+1;j<n-1;j++)
            {
                int right = j+1;
                
                while(right<n)
                {
                    if(nums[i]+nums[j]>nums[right])
                        count++;
                    right++;
                }
            }
        }
        return count;
    }
 
}

后来看了下评论，是固定最大的，然后一个左指针，一个右指针。

class Solution {
    public int triangleNumber(int[] nums) {
        
        
        int n = nums.length;
        if(n<3) return 0;
        int count = 0;
        Arrays.sort(nums);
       
       for(int k = n-1;k>=2;k--)
       {
           int left = 0;
           int right = k-1;

           while(left<right)
           {
               if(nums[left]+nums[right]>nums[k])
               {
                   count+=right-left;
                   right--;
               }
               else 
               {
                   left++;
               }

           }
       }
        return count;
    }
 
}

开始不明白为什么是count+=right-left;后来才知道，因为已经排好序了，left right 和k可以，那么left到right-1的也一直可以嗄，就是nums[left]+nums[right]>nums[k]，比较他们在一直增大的。

力扣第802题：找到最终的安全状态（重）

这道题大致一看知道是递归，但是具体怎么做却不会，看了评论，用了两个数组来标记，一个用来标记是否访问过，另一个用来看是否是安全点。最后将安全的点加入list中。

class Solution {
    public List<Integer> eventualSafeNodes(int[][] graph) {
    
        List<Integer> list = new ArrayList<>();
        int n = graph.length;
        int[] flag = new int[n];//0未访问  1 安全  2不安全
        boolean visited[] =new boolean[n];

        for(int i = 0 ;i<n;i++)
        {
            dfs(graph,flag,visited,i);
        }

        for(int i = 0 ; i<n;i++)
        {
            if(flag[i]==1) list.add(i);
        }
        return list;

    }  
    boolean dfs(int[][] graph,int[] flag,boolean visited[],int start)
    {
        if(flag[start]!=0)
        {
            if(flag[start] == 1) return true;
            else return false;
        }
        boolean res = true;
        for(int i:graph[start])
        {
            if(visited[i]) return false;
            visited[i] = true;
            res = res&&dfs(graph,flag,visited,i);
            visited[i] = false;
        }

        if(res) flag[start] = 1;
        else flag[start] = 2;

        return res;
    }
}

之前做了好多递归的题，这道题还是没有做出来，哎，这习题需要去理解，不能只抄了一遍又忘了。
里面爱写错的地方在for(int i:graph[start])我开始写成了for(int i = 0 ;i<graph[strat].length;i++)，这样不会，这样的长度 是列的长度了，我们要获取行的长度，还有最后if（res）这一块，需要给flag赋值看看是否是安全的点。

力扣第443题：压缩字符串

这道题我看到就想到使用hashmap了，其它的就不知道怎么用，先把这个写出来吧。

Map<Character,Integer> map = new HashMap<>();
        for(int i = 0 ;i<n;i++)
        {
            if(map.containsKey(chars[i]))
            {
                map.put(chars[i],map.get(chars[i])+1);
            }
            else
            {
                map.put(chars[i],1);
            }
        }
        int count = 0;
        for(Map.Entry entry:map.entrySet())
        {
            char key = (char) entry.getKey();
            count++;
            int value = (int) entry.getValue();
            String s = value+"";
            count+=s.length();
        }
        return  count;

运行后发现需要的是字符串，虽然返回的是int，但是还要在原来的chars上进行修改，这一点我没做到，所以，应该在数组上进行计算才对。尝试继续修改。
我又重新写了一个，但是还是有问题，没有在原数组上进行修改

class Solution {
    public int compress(char[] chars) {
        int n = chars.length;
        if(n==0) return 0 ;
        if(n==1) return 1;

        int left= 0;
        //int right = 0;

        StringBuilder sb = new StringBuilder();
        for(int i = 1;i<n;i++)
        {
            int count = 1;
            
           if(chars[left]==chars[i])    sb.append(chars[i]);
          
           //if(left==0&&chars[left]!=chars[i]) sb.append(chars[left]);
            

            while(i<n&&chars[left]==chars[i])
            {
                count++;
                i++;
            }
            if(count!=1) sb.append(count);
            left +=count; 
        }
        char s[] = sb.toString().toCharArray();
        for(int i = 0;i<s.length;i++)
        {
            chars[i] = s[i];
        }
        return s.length;

    }
}

这样写依然存在问题，所以我准备看一下答案。
看到一个评论和我得想法很相似。

class Solution {
    public int compress(char[] chars) {
        int n = chars.length;
        if(n==0) return 0 ;
        if(n==1) return 1;
       
        StringBuilder sb = new StringBuilder();
        int count = 1 ;
        char c = chars[0];
        sb.append(c);
        for(int i = 1 ;i<n;i++)
        {
            if(c==chars[i])
            {
                count++;
            }
            else
            {
                if(count!=1)
                {
                    sb.append(count);
                }
                c=chars[i];
                sb.append(c);
                count = 1;
            }
        }
        if(count!=1) //最后一个元素
        {
            sb.append(count);
        }

        char s[] = sb.toString().toCharArray();
        for(int i = 0 ;i<s.length;i++)
        {
            chars[i]=s[i];
        }

        return s.length;
      
    }
}

现在来看双指针的方法：

class Solution {
    public int compress(char[] chars) {
        int n = chars.length;
        int read = 0 ;//读
        int write = 0;//写
        int cur = 0;//当前位置
        while(read<n)
        {
            while(read<n&&chars[read]==chars[write])
            {
                read++;
            }
            chars[cur++] =chars[write];
            if(read-write>1)
            {
                for(char c:String.valueOf(read-write).toCharArray())
                {
                    chars[cur++] = c;
                }
            }
            write = read;
        }
       return cur;
    }
}

双指针的方法将read-write 转换成了字符串直接加进去了。

力扣第8题：字符串转整数

这道题自己之前做过，这次做还是在用if，if语句判断不过来的，还是得按照一个位一个位的数过去，看他到底是什么，还有用到了Character.isDigit()函数，判断是否数字，我之前的是s.charAt(i)>‘0’&&s.charAt(i)<‘9’，乍一看可以，但是0和数字9 就被忽略了。这题更多的是细节呀。

力扣第13题：罗马数字转整数

这道题之前也做过，这次做的时候就想到使用hashmap，但是在处理特殊的字符如‘IV’时候却犯了难，看了下评论，原来可以将那些特殊字符替换，正常情况下 从左到右逐渐减小的，当这个字符的值小于下一个字符，那就是sum-=。其它的就是+=。

力扣第12题：整数转罗马数字

这道题之前也做过，我怎么还在想着用hashmap，这道题一个数组存字符串，一个数组存int，然后num一直减，字符串一直加就行了。
这些做过的题也得后头看，不看就忘了。

总结

做的题不多，而且有些松懈，每晚做完之后没有总结，直接走了，所以第二天早上才来总结，不太好…
先做的每日一题，每日一题看了很久都没做出来，一直练，还有做的题比较繁琐，自己有些不耐烦，有三道题自己之前做过，但是在写的时候竟然还是磕磕绊绊，这也太low了，还有就是管它会不会，先去写，得思考，别老是看答案，不是个好表现，加油！