LeetCode Weekly Contest 23

1. 541. Reverse String II

按照题目要求的做就行，没有特殊考虑的边界条件。

class Solution {
public:
string reverseStr(string s, int k) {
    int n = s.size();
    if(k == 1) {
        return s;
    }
    if(n <= k) {
        reverse(s.begin(), s.end());
        return s;
    }
    int i = 0;
    while(i < n) {
        if(i + k >= n) {
            reverse(s.begin() + i, s.end());
        } else {
            reverse(s.begin() + i, s.begin() + i + k);
        }
        i += 2 * k;
    }
    return s;
}
};

2. 539. Minimum Time Difference

把字符串转化为数字，都转化为以分钟为单位，然后排序，结果一定在相邻的2个之间产生，注意第一个和最后一个。以及每个差值的补数。

class Solution {
public:
int findMinDifference(vector<string>& ti) {
    vector<int> v;
    for(string s : ti) {
        int t = 0;
        t = ((s[0] - '0') * 10 + s[1] - '0') * 60 + (s[3] - '0') * 10 + s[4] - '0';
        v.push_back(t);
    }
    sort(v.begin(), v.end());
    int res = INT_MAX;
    int n = v.size();
    for(int i = 0; i < n; i++) {
        int t = abs(v[(i + 1) % n] - v[i]);
        res = min(res, min(t, 1440 - t));
    }
    return res;
}
};

3. 536. Construct Binary Tree from String

显然是要递归调用，每个数字后面可能有0,1,2对匹配的括号，对应相应的儿子。考虑有无限对括号的情况（当然这个题目是二叉树），这跟前面的一些题目，parser类的题目很相似，解析类的题目，都是要递归调用，考虑不同的结构。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
TreeNode* work(string &s, int& p) {
    int n = s.size();
    if(p >= n) return NULL;
    if(!(s[p] == '-' || (s[p] >= '0' || s[p] <= '9'))) return NULL;
    int f = 1;
    if(s[p] == '-') {
        f = -1;
        p++;
    }
    int t = 0;
    while(p < n && s[p] >= '0' && s[p] <= '9') {
        t = t * 10 + s[p] - '0'; p++;
    }
    t *= f;
    TreeNode*tr = new TreeNode(t);
    if(p < n && s[p] == '(') {
        p++;
        tr->left = work(s, p);
        p++;
    }
    if(p < n && s[p] =='(') {
        p++;
        tr->right = work(s, p);
        p++;
    }
    return tr;
}
TreeNode* str2tree(string s) {
    int n = s.size();
    int t = 0;
    return work(s, t);
}
};

4. 527. Word Abbreviation

看的前面大神的代码，基本上都是暴力，可能400*400（个数和单词长度）的数据范围太小了吧！维护一下压缩后的长度，长度为1的就是最终结果，大于1的需要扩展压缩长度，重复这个过程，直到结果。

分析：字符串长度小于等于3的，结果是原字符串，然后考虑其他的，考虑产生冲突的情况，肯定是长度相同的，长度不同的一定不会产生冲突（这个应该是肯定的）。然后对长度相同的进行处理，找出不同的字符表示，当这个字符只有一个字符串包含的时候，这个字符串的压缩方式就确定了，然后就是用trie树，维护一下个数，插入所有，然后对每一个字符串，找到只出现一次的字符，输出压缩结果。由于初始压缩方式只有头尾字符以及中间个数，所以，插入trie树的时候，先插入末尾字符，再插入其他字符。

struct node {
    int c;
    int nxt[26];
    void clear() {
        c = 0;
        memset(nxt, 0, sizeof nxt);
    }
} e[160010];
int cnt;
class Solution {
public:

vector<string> di;
vector<string> res;
void add(string& s) {
    int u = 0;
    for (char ch : s) {
        int cur = ch - 'a';
        if(e[u].nxt[cur] == 0) {
            e[u].nxt[cur] = ++cnt;
            e[cnt].clear();
        }
        u = e[u].nxt[cur];
        e[u].c++;
    }
}
void work(vector<int> &v) {
    //cout << v.size() << endl;
    //cout << "asd " << v[0] << endl;
    cnt = 0;
    e[0].clear();
    int n = v.size();
    int len = di[v[0] ].size();
    if(n == 1) {
        stringstream ss;
        ss << di[v[0] ][0];
        ss << len - 2;
        ss << di[v[0] ][len - 1];
        res[v[0] ] = ss.str();
        return;
    }
    for (int x : v) {
        string t = di[x];
        string td = t[len - 1] + t.substr(0, len - 1);
        add(td);
    }
    for (int x : v) {
        string t = di[x];
        string td = t[len - 1] + t.substr(0, len - 1);
        int u = 0;
        bool f = 1;
        for (int i = 0; i < len; i++) {
            int cur = td[i] - 'a';
            u = e[u].nxt[cur];
            if(e[u].c == 1) {
                stringstream ss;
                if(i == 0)
                    ss << t[0];
                else
                    ss << td.substr(1, i);
                if(len - i - 1 > 0)
                    if(i > 0)
                        ss << (len - i - 1);
                    else
                        ss << (len - 2);
                ss << td[0];
                res[x] = ss.str();
                if(res[x].size() >= di[x].size())
                    res[x] = di[x];
                //cout << "res " << res[x] << endl;
                f = 0;
                break;
            }
        }
        if(f) cout << "err" << endl;
    }
}
vector<string> wordsAbbreviation(vector<string>& dict) {
    di = dict;
    int n = dict.size();
    map<int, vector<int>> ma;
    res.clear();
    res.resize(n);
    for (int i = 0; i < n; i++) {
        string s = dict[i];
        if(s.size() <= 3) {
            res[i] = s;
        } else {
            int t = s.size();
            ma[t].push_back(i);
        }
    }
    //cout << "asd" << endl;
    for (auto it : ma) {
        auto& x = it.second;
        //for (int t : x)
        //    cout << t << " ";
        //cout << endl;
        work(x);
    }
    return res;
}
};