[leetcode]Weekly Contest 68 （767. Reorganize String&&769. Max Chunks To Make Sorted&&768. Max Chunks To Make Sorted II）

766. Toeplitz Matrix

第一题不说，贼麻瓜，好久没以比赛的状态写题，这个题浪费了快40分钟，我真是。。。。。。

767. Reorganize String

就是给你一个字符串，能不能转换成：任意一个字符S[i]，使得S[i-1]和S[i+1]都不等于S[i]。如果能输出，不能就输出一个空字符串。

大一的时候好像有印象，队友做出来的，贪心吧，如果遇到相邻两个一样的，就从后面找一个插到中间，具体原理我也不知道为什么，反正是对的，从头到尾扫一遍，再倒着来一遍，为什么要两边我也不知道，反正是对的。。。我也很凌乱啊！！！

 class Solution {
 public:
     string reorganizeString(string S) {
         int len = S.size();
         string ts = S;
         bool ans1 = true;
         for(int i=;i<len;i++)
         {
             if(ts[i]==ts[i+]) {
                 if(i == len-) ans1 = false;
                 for(int j=i+;j<len;j++)
                 {
                     if(ts[j]!=ts[i] && ts[j]!=ts[i+])
                     {
                         swap(ts[j], ts[i+]);
                         break;
                     }
                     if(j == len-) {
                         ans1 = false;
                     }
                 }
             }
         }
         string ts2 = ts;
         reverse(ts2.begin(), ts2.end());
         bool ans2 = true;
         for(int i=;i<len;i++)
         {
             if(ts2[i]==ts2[i+]) {
                 if(i == len-) ans2 = false;
                 for(int j=i+;j<len;j++)
                 {
                     if(ts2[j]!=ts2[i] && ts2[j]!=ts2[i+])
                     {
                         swap(ts2[j], ts2[i+]);
                         break;
                     }
                     if(j == len-) {
                         ans2 = false;
                     }
                 }
             }
         }
         if(ans1){
             return ts;
         }
         else if(ans2) {
             return ts2;
         }
         else {
             return "";
         }
     }
 };

769. Max Chunks To Make Sorted

给你一个序列，问你把这个序列分成n块，每个块单独排序，且排完序后和整体排序得到的结果要一模一样，求n的最大值

因为这个题说了，序列的内容是0——length-1，所以序列的内容唯一且连续

遍历序列从i到length-1，对前i的内容进行求最大值max，和最小值min，若在前i的序列中，min == 下标的最小值，max == 下标的最大值，即最小块，只是比赛时想到的，虽然也对，但太麻烦

 class Solution {
 public:
     int maxChunksToSorted(vector<int>& arr) {
         int ans = ;
         int start = ;
         while(start != arr.size()){
             int min = arr[start], max = arr[start];
             for(int end=start;end<arr.size();end++)
             {
                 max = max>arr[end]?max:arr[end];
                 min = min<arr[end]?min:arr[end];
                 if(min == start&&max == end) {
                     ans ++;
                     start = end + ;
                     break;
                 }
             }
         }
         return ans;
     }
 };

题解，只用求最大值就可以了，因为所以序列的内容唯一且连续，所以若arr[i]为最大值且 i == arr[i]，则说明，小于 i的部分已经可以且一定顺序连续地排序

 class Solution(object):
     def maxChunksToSorted(self, arr):
         ans = ma = 0
         for i, x in enumerate(arr):
             ma = max(ma, x)
             if ma == i: ans += 1
         return ans

768. Max Chunks To Make Sorted II

这是第二题的升级版

序列里的内容不一定（唯一且连续）了，其他都是一样的

我们来看一个特殊的序列1，1，0，0，1

对于正确的序列来说，是0，0，1，1，1

如果用上一种方法，那么到第三个数的时候，ans就要加一了

所以判断是否是最小且正确的块的时候，还要判断，前面出现的内容，和全部排好序的序列，是否一致

我在这里引入一个已遍历的序列和作为判断，这个算法的正确性，我还不得而知，我自己甚至认为可能不对，因为我数学学得是真的烂。。。。。。

希望若有人证明是正确的可以告诉我

 class Solution:
     def maxChunksToSorted(self, arr):
         ans = 0
         sum1 = 0
         sum2 = 0
         arr_pre_max = arr[0]
         tarr = sorted(arr)
         for x, y in zip(arr, tarr):
             sum1 += x
             sum2 += y
             arr_pre_max = max(arr_pre_max, x)
             if arr_pre_max == y and sum1 == sum2:
                 ans += 1
         return ans

最后一题没做看起来很难的样子