LeetCode Weekly Contest 20

1. 520. Detect Capital

题目描述的很清楚，直接写，注意：字符串长度为1的时候，大写和小写都是满足要求的，剩下的情况单独判断。还有：我感觉自己写的代码很丑，判断条件比较多，需要改进，精简再精简。

class Solution {
public:
bool detectCapitalUse(string word) {
    int n = word.size();
    if(n == 1) return 1;
    if(word[0] <= 'Z') {
        bool f = 1;
        for (int i = 1; i < n; i++) {
            if(word[i] >= 'a') {}
            else {
                f = 0; break;
            }
        }
        if(f) return 1;
        f = 1;
        for (int i = 1; i < n; i++) {
            if(word[i] < 'a') {}
            else {
                f = 0; break;
            }
        }
        if(f) return 1;
    } else {
        bool f = 1;
        for (int i = 1; i < n; i++) {
            if(word[i] < 'a') {
                f = 0; break;
            }
        }
        if(f) return 1;
    }
    return 0;
}
};

2. 526. Beautiful Arrangement

看完题目，感觉数据范围很小，1<<15 = 32000，(这里不对，应该是15！，这个数字很大，暴力是不行的，之前的分析是错的！)比较小的，使用next_permutation暴力，枚举， 然后tle， 我就想着本地打表计算，直接输出结果，谁知道13,14,15的结果根本出不来。

后来看11,12的答案挺小，然后想着预处理出每个位置可以放的数字，然后dfs进行解的搜索，本地测试1-15，出解的速度很快，然后提交，就ac了。

class Solution {
public:
vector<int> e[20];
bool in[20];
int res;
int tn;
void work(int u) {
    if(u > tn) {
        bool f = 1;
        for (int i = 1; i <= tn; i++) {
            if(!in[i]) {
                f = 0; break;
            }
        }
        res += f;
        return;
    }
    for (int x : e[u]) {
        if(in[x]) continue;
        in[x] = 1;
        work(u + 1);
        in[x] = 0;
    }
}
int countArrangement(int n) {
    if(n < 3) return n;
    tn = n;
    for (int i = 1; i <= n; i++) {
        e[i].clear();
        for (int j = 1; j <= n; j++) {
            if(j % i == 0 || i % j == 0)
                e[i].push_back(j);
        }
    }
    memset(in, 0, sizeof in);
    work(1);
    return res;
}
};

3. 525. Contiguous Array

这道题是原题，但是看完，想不出来递推方程，只好找以前的答案，幸好保存了，我是传送门 http://www.cnblogs.com/y119777/p/5851025.html，多亏当初还仔细分析了一下，考虑了各种情况。

然后抄，提交，ac。

class Solution {
public:
int getLongestString(vector<int> & v) {
    int n = v.size();
    if(n < 2) return 0;
    map<int, int> m;
    int s = 0;
    int res = 0;
    for(int i = 0; i < n; i++) {
        s += v[i];
        if(s == 0) {
            res = max(res, i + 1); continue;
        }
        if(!m.count(s)) {
            m[s] = i;
        } else {
            int len = i - m[s];
            res = max(res, len);
        }
    }
    return res;
}
    int findMaxLength(vector<int>& nums) {
        int n = nums.size();
        if(n < 2) return 0;
        for (int i = 0; i < n; i++)
            if(nums[i] == 0) nums[i] = -1;
        return getLongestString(nums);
    }
};

4。 517. Super Washing Machines

先看数据范围[0,1e4], [1, 1e5], 1e9,使用int，不会溢出。（时刻牢记这个坑，有时候最后结果不会溢出，但是，中间结果可能溢出）。n^2的复杂度有点高，而且。我也不知道n^2的解法怎么写！

一看hard，想不出思路，感觉要跪！这时候，一定提醒自己，静下心来，从最简单的例子入手，分析，有什么优秀的性质可以利用，考虑解法。

第一：不难想到，长度小于2，直接返回0，然后求和，结果不是长度的倍数，就直接返回-1，剩下的情况一定可以出结果。

第二：想不出n^2的方法，那就是复杂度为n的枚举方法，按这种枚举出来的结果，就是最优的。然后记 s = s / n; s为每个数字最后的目标，小于s的需要，至少需要s-a次，大于s的需要a-s次，然后考虑是否可以同时进行，由于每个数字互不干扰，每个数字每次移出只能移出1，所以只需要统计每个数字移出的次数，最后的结果就是最大的那个数字。仔细，思考一下，最好画一画。

class Solution {
public:
int findMinMoves(vector<int>& mach) {
    int n = mach.size();
    if(n < 2) return 0;
    int s = 0;
    for (int x : mach)
        s += x;
    if(s % n != 0) {
        return -1;
    }
    if(s == 0) return 0;
    vector<int> c(n, 0);
    s /= n;
    int res = 0;
    for (int i = 0; i < n; i++) {

        int t = mach[i] + c[i];

        if(t == s) {

        } else if(t < s) {
            c[i + 1] -= s - t;
        } else if(t > s) {
            c[i] -= t - s;
            mach[i + 1] += t - s;
            //c[i + 1] += t - s;
        }
        res = max(res, abs(c[i]));
        //cout << c[i] << endl;

    }
    return res;
}
};