[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=0;i<len;i++)
        {
            if(ts[i]==ts[i+1]) {
                if(i == len-2) ans1 = false;
                for(int j=i+2;j<len;j++)
                {
                    if(ts[j]!=ts[i] && ts[j]!=ts[i+1])
                    {
                        swap(ts[j], ts[i+1]);
                        break;
                    }
                    if(j == len-1) {
                        ans1 = false;
                    }
                }
            }
        }
        string ts2 = ts;
        reverse(ts2.begin(), ts2.end());
        bool ans2 = true;
        for(int i=0;i<len;i++)
        {
            if(ts2[i]==ts2[i+1]) {
                if(i == len-2) ans2 = false;
                for(int j=i+2;j<len;j++)
                {
                    if(ts2[j]!=ts2[i] && ts2[j]!=ts2[i+1])
                    {
                        swap(ts2[j], ts2[i+1]);
                        break;
                    }
                    if(j == len-1) {
                        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 = 0;
        int start = 0;
        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 + 1;
                    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

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