10.12-10.25 字符串

//这周做一下字符串的题目，感觉时间越来越不够用==

1.487-3279(简单题)

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <fstream>
#include <cstdlib>
#define NDEBUG
#include <cassert>

using namespace std;

#define INF 1000000007
#define MIN(a, b) (a > b ? b : a)
#define MAX(a, b) (a > b ? a : b)
#define MAXN 105

int ch[400];
char c[50];

void init()
{
    ch['A'] = ch['B'] = ch['C'] = 2;
    ch['D'] = ch['E'] = ch['F'] = 3;
    ch['G'] = ch['H'] = ch['I'] = 4;
    ch['J'] = ch['K'] = ch['L'] = 5;
    ch['M'] = ch['N'] = ch['O'] = 6;
    ch['P'] = ch['R'] = ch['S'] = 7;
    ch['T'] = ch['U'] = ch['V'] = 8;
    ch['W'] = ch['X'] = ch['Y'] = 9;
}

int main()
{
    int n, flag = 0;
    init();
    scanf("%d", &n);
    getchar();
    map<int, int> mp;
    for (int i = 0; i < n; ++i)
    {
        gets(c);
        int tmp = 0;
        for (int j = 0; j < strlen(c); ++j)
        {
            if (c[j] == '-') continue;
            if (c[j] >= 'A' && c[j] <= 'Z') tmp = tmp*10+ch[c[j]];
            else if (c[j] >= '0' && c[j] <= '9') tmp = tmp*10 + (c[j]-'0');
        }
        mp[tmp]++;
    }
    for (map<int, int>::iterator it = mp.begin(); it != mp.end(); ++it)
        if (it->second > 1 ) flag = 1,printf("%03d-%04d %d
", (it->first)/10000, (it->first)%10000, it->second);
    if (!flag) puts("No duplicates. ");
    
    return 0;
}

 2.Crazy Search(简单题，karp-Rabin)

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <fstream>
#include <cstdlib>
using namespace std;

#define INF 1000000007
#define MIN(a, b) (a > b ? b : a)
#define MAX(a, b) (a > b ? a : b)
#define MAXN 105

int n, nc;
char ch[1000000];
int c[400];
int t[16000005];

int main()
{
    while (~scanf("%d%d", &n, &nc))
    {
        scanf("%s", ch);
        int len = strlen(ch), cnt = 0;
        for (int i = 0; i < len; ++i)
        {
            if (c[ch[i]] == 0) c[ch[i]] = ++cnt;
            if (cnt == nc) break;
        }
        int num = 0, val = 1;
        for (int i = 0; i < n; ++i)
        {
            num = num*nc+c[ch[i]]-1;
            val *= nc;    
        }
        val /= nc;
        t[num] = 1;
        int ans = 1;
        for (int i = 1; i <= len-n; ++i)
        {
            num = (num-(c[ch[i-1]]-1)*val)*nc+c[ch[i+n-1]]-1;
            if (!t[num]) t[num] = 1, ans++;
        }
        printf("%d
", ans);
    }
    return 0;    
}

 3.Game of Life(简单偏上一点点)

//模拟人生游戏，比较简单，题目要求原地操作，用特殊值即可
int dir[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
class Solution {
public:
    void gameOfLife(vector<vector<int>>& board) {
        if (board.size() == 0) return ;
        for (int i = 0; i < board.size(); ++i)
        {
            for (int j = 0; j < board[i].size(); ++j)
            {
                int die = 0, live = 0;
                for (int k = 0; k < 8; ++k)
                {
                    int xx = i + dir[k][0];
                    int yy = j + dir[k][1];
                    if (xx >= 0 && xx < board.size() && yy >= 0 && yy < board[i].size())
                    {
                        if (board[xx][yy] == 2) die++;
                        else if (board[xx][yy] == 1) live++;
                        else if (board[xx][yy] == 0) die++;
                        else live++;
                    }
                }
                if (board[i][j])
                {
                    if (live < 2) board[i][j] = -1;
                    if (live == 2 || live == 3) continue;
                    if (live > 3) board[i][j] = -1;
                }
                else if (live == 3) board[i][j] = 2;
            }
        }
        for (int i = 0; i < board.size(); ++i)
            for (int j = 0; j < board[i].size(); ++j)
                board[i][j] = board[i][j] > 0 ? 1 : 0;
    }
};

4.Nim Game(简单题)

//简单博弈
class Solution {
public:
    bool canWinNim(int n) {
        if (n < 4) return true;
        if ((n-1)%4 == 0) return true;
        if ((n-2)%4 == 0) return true;
        if ((n-3)%4 == 0) return true;
        return false;
    }
};

 5.Subsets II(中等题)

//奇丑无比的代码……
class Solution {
public:
    vector<int> num;
    vector<vector<int>> ans;
    int len = 0, size, cnt;
    void work(int idx, vector<int>& tmp)
    {
        if (tmp.size() > size) return ;
        if (idx == len)
        {
            if (cnt != size) return ;
            else ans.push_back(tmp);
        }
        if (size == cnt)
        {
            ans.push_back(tmp);
            return ;
        }
        for (int i = idx; i < len; ++i)
        {
            tmp.push_back(num[i]);
            cnt++;
            work(i+1, tmp);
            tmp.pop_back();
            cnt--;
        }
    }
    
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        num = nums;
        len = nums.size();
        for (int i = 0; i <= nums.size(); ++i)
        {
            vector<int> tmp;
            size = i;
            cnt = 0;
            work(0, tmp);
        }
        vector<vector<int>> ret;
        sort(ans.begin(), ans.end());
        ret.push_back(ans[0]);
        for (int i = 1; i < ans.size(); ++i)
        {
            if (ans[i] != ans[i-1]) ret.push_back(ans[i]);
        }
        return ret;
    }
};

 6.Convert Sorted List to Binary Search Tree(中等题)

//两个指针，快慢指针找到中点，然后递归
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * 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* sortedListToBST(ListNode* head) {
        if (head == NULL) return NULL;
        ListNode *t1, *t2, *pre = NULL;
        t1 = head, t2 = head;
        while (t1->next != NULL && t2 != NULL && t2->next != NULL)
        {
            pre = t1;
            t1 = t1->next;
            t2 = t2->next;
            if (t2->next == NULL) break;
            t2 = t2->next;
        }
        TreeNode* node = new TreeNode(t1->val);
        if (pre != NULL)
        {
            pre->next = NULL;
            node->left = sortedListToBST(head);
        }
        node->right = sortedListToBST(t1->next);
        return node;
    }
};

 7.Peeking Iterator

// Below is the interface for Iterator, which is already defined for you.
// **DO NOT** modify the interface for Iterator.
class Iterator {
    struct Data;
    Data* data;
public:
    Iterator(const vector<int>& nums);
    Iterator(const Iterator& iter);
    virtual ~Iterator();
    // Returns the next element in the iteration.
    int next();
    // Returns true if the iteration has more elements.
    bool hasNext() const;
};


class PeekingIterator : public Iterator {
public:
    PeekingIterator(const vector<int>& nums) : Iterator(nums) {
        this->next();
    }

    // Returns the next element in the iteration without advancing the iterator.
    int peek() {
        return next_val;
    }

    // hasNext() and next() should behave the same as in the Iterator interface.
    // Override them if needed.
    int next() {
        int ret = next_val;
        if (Iterator::hasNext())
        {
            b_next = true;
            next_val = Iterator::next();
        }
        else b_next = false;
    
        return ret;
    }

    bool hasNext() const {
        return  b_next;
    }
private:
    bool b_next;
    int next_val;
};

 8.House Robber II(简单DP)

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        int ans = 0;
        int dp[1000][2];
        dp[0][0] = dp[0][1] = 0;
        for (int i = 1; i < nums.size(); ++i)
        {
            dp[i][0] = dp[i-1][1];
            dp[i][1] = dp[i-1][0]+nums[i];
            dp[i][1] = max(dp[i][0], dp[i][1]);
        }
        ans = max(dp[nums.size()-1][0], dp[nums.size()-1][1]);
        memset(dp, 0, sizeof(dp));
        dp[0][0] = dp[0][1] = nums[0];
        for)(int i = 1; i < nums.size(); ++i)
        {
            dp[i][0] = dp[i-1][1];
            dp[i][1] = dp[i-1][0]+nums[i];
            if (i == 1) dp[i][1] = nums[1];
            dp[i][1] = max(dp[i][0], dp[i][1]);
        }
        ans = max(ans, dp[nums.size()-1][0]);
        return ans;
    } 
};

 9.Bitwise AND of Numbers Range(位操作)

class Solution {
public:
    int rangeBitwiseAnd(int m, int n) {
        if (m == 0) return 0;
        if (m == n) return m;
        long long int tmp = 1;
        while (tmp < m) tmp *= 2;
        if (tmp > m && tmp < n) return 0;
        if (tmp == n) return 0;
        if (tmp*2 <= n) return 0;
        if (tmp == m && tmp*2 > n) return m; 
        return tmp/2+rangeBitwiseAnd(m-tmp/2, n-tmp/2);
    }
};

 10.Reverse Linked List II(中等)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverse(ListNode* head)
    {
        if (head == NULL) return NULL;
        if (head->next == NULL) return head;
        ListNode *fir = head, *sec = head->next;
        head->next = NULL;
        while (sec != NULL)
        {
            ListNode* tmp = sec->next;
            sec->next = fir;
            fir = sec;
            sec = tmp;
        }
        return fir;
    }
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        int idx = 1;
        ListNode *first = new ListNode(0);
        first->next = head;
        ListNode *pre = first, *tmp = head;
        while (idx != m)
        {
            pre = tmp;
            tmp = tmp->next;
            idx++;
        }
        ListNode *l1 = tmp;
        while (idx != n)
        {
            tmp = tmp->next;
            idx++;
        }
        ListNode *last = tmp->next;
        tmp->next = NULL;
        ListNode* ret = reverse(l1);
        pre->next = ret;
        while (ret->next != NULL) ret = ret->next;
        ret->next = last;
        ret = first->next;
        delete first;
        return ret;
    }
};

 11.Next Permutation(中等偏下)

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int flag = 1;
        for (int i = nums.size()-1; i > 0; --i)
        {
            if (nums[i] > nums[i-1])
            {
                for (int j = nums.size()-1; j >= i; j--)
                {
                    if (nums[j] > nums[i-1]) 
                    {
                        swap(nums[j], nums[i-1]);
                        flag = 0;
                        break;
                    }
                }
                int j = i, k = nums.size()-1;
                while (j < k)
                {
                    swap(nums[j], nums[k]);
                    j++, k--;
                }
                break;
            }
        }
        if (flag)
        {
            int j = 0, k = nums.size()-1;
            while (j < k)
            {
                swap(nums[j], nums[k]);
                j++, k--;
            }
        }
    }
};

 12.Minimum Size Subarray Sum(two points)

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        vector<int> dp(nums.size()+1, 0);
        if (nums.size() == 0) return 0;
        dp[1] = nums[0];
        for (int i = 1; i < nums.size(); ++i)
            dp[i+1] = dp[i]+nums[i];
        int ans = 1e9;
        int i = 0, j = 1;
        while (i <= j && j <= nums.size())
        {
            if (dp[j]-dp[i] >= s)
            {
                if (j-i < ans) ans = j-i;
                i++;
            }
            else j++;
        }
        if (ans == 1e9) return 0;
        return ans;
    }
};

 13.Palindrome(曼彻斯特算法)

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <list>
#include <queue>

using namespace std;

char ch1[1000010];
char ch2[2000010];
int p[2000010];

void build()
{
    ch2[0] = '@';
    ch2[1] = '#';
    int i, len = strlen(ch1);
    for (i = 0; i < len; ++i)
    {
        ch2[2*i+2] = ch1[i];
        ch2[2*i+3] = '#';
    }
    ch2[2*i+2] = '';
}

int solve()
{
    p[0] = p[1] = 1;
    int id = 1, mx = 2, maxlen = 0;
    for (int i = 2; ch2[i]; ++i)
    {
        p[i] = mx > i ? min(p[2*id-i], mx-i) : 1;
        while (ch2[i+p[i]] == ch2[i-p[i]]) p[i]++;
        if (i+p[i] > mx)
        {
            mx = i+p[i];
            id = i;
        }
        maxlen = max(maxlen, p[i]-1);
    }
    return maxlen;
}

int main()
{
    int ncas = 1;
    while (~scanf("%s", ch1) && strcmp(ch1, "END") != 0)
    {
        build();
        printf("Case %d: %d
", ncas++, solve());
    }

    return 0;
}

 14.Find the Duplicate Number(回溯/回文串/中等题目)

int dp[1000][1000];
class Solution {
public:
    int judge(int left, int right, string& str)
    {
        while (left < right)
        {
            if (str[left] == str[right])
                left++, right--;
            else return 0;
        }
        return 1;
    }
    void work(string& s, int idx, vector<string>&add, vector<vector<string>>&ans)
    {
        if (idx == s.length())
        {
            ans.push_back(add);
            return ;
        }
        string str = "";
        for (int i = idx; i < s.length(); ++i)
        {
            str += s[i];
            if (dp[idx][i])
            {
                add.push_back(str);
                work(s, i+1, add, ans);
                add.pop_back();
            }
        }
    }
    
    vector<vector<string>> partition(string s) {
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < s.length(); ++i)
            for (int j = i; j < s.length(); ++j)
                dp[i][j] = judge(i, j, s);
        vector<string> add;
        vector<vector<string>> ans;
        add.clear();
        ans.clear();
        work(s, 0, add, ans);
        return ans;
    }
};

 15.Find the Duplicate Number(Cycle detection/难题(难在问题转化)) 

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int slow = 0;
        int fast = 0;
        do{
            slow = nums[slow];
            fast = nums[nums[fast]];
        } while(slow != fast);
        int find = 0;
        while(find != slow){
            slow = nums[slow];
            find = nums[find];
        }
        return find;
    }
};

 16.Implement Trie (Prefix Tree)(字典树/中等题)

class TrieNode {
public:
    bool flag;
    TrieNode* node[26];
    // Initialize your data structure here.
    TrieNode() {
        flag = false;
        memset(node, 0, sizeof(node));
    }
};

class Trie {
public:
    Trie() {
        root = new TrieNode();
    }

    // Inserts a word into the trie.
    void insert(string word) {
        TrieNode *top = root;
        for (int i = 0; i < word.length(); ++i)
        {
            if (top->node[word[i]-'a'] == NULL)
            {
                TrieNode* tmp = new TrieNode();
                top->node[word[i]-'a'] = tmp;
            }
            top = top->node[word[i]-'a'];
        }
        top->flag = true;
    }

    // Returns if the word is in the trie.
    bool search(string word) {
        TrieNode* top = root;
        for (int i = 0; i < word.length(); ++i)
        {
            if (top->node[word[i]-'a'] == NULL) return false;
            top = top->node[word[i]-'a'];
        }
        return top->flag;
    }

    // Returns if there is any word in the trie
    // that starts with the given prefix.
    bool startsWith(string prefix) {
        TrieNode *top = root;
        for (int i = 0; i < prefix.length(); ++i)
        {
            if (top->node[prefix[i]-'a'] == NULL) return false;
            top = top->node[prefix[i]-'a'];
        }
        return true;
    }

private:
    TrieNode* root;
};

 17.Copy List with Random Pointer(STL/map/中等偏上)

/**
 * Definition for singly-linked list with a random pointer.
 * struct RandomListNode {
 *     int label;
 *     RandomListNode *next, *random;
 *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
 * };
 */
class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        RandomListNode *t = head, *first = NULL, *pre;
        map<RandomListNode*, RandomListNode*> mp;
        while (t)
        {
            RandomListNode *tmp = new RandomListNode(t->label);
            if (first == NULL) first = tmp, pre = tmp;
            else pre->next = tmp, pre = tmp;
            mp[t] = tmp;
            t = t->next;
        }
        t = head;
        pre = first;
        while (t)
        {
            if (t->random != NULL)
                pre->random = mp[t->random];
            t = t->next;
            pre = pre->next;
        }
        return first;
    }
};

 18.Oulipo(KMP)

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <list>
#include <queue>

using namespace std;

int nxt[10010];
char ch1[1000010], ch2[10010];

void getNext()
{
    nxt[0] = -1;
    int j = -1, len = strlen(ch2);
    for (int i = 1; i < len; ++i)
    {
        while (j >= 0 && ch2[i] != ch2[j+1]) j = nxt[j];
        if (ch2[j+1] == ch2[i]) j++;
        nxt[i] = j;
    }
}

int work()
{
    int cnt = 0;
    int j = -1, len1 = strlen(ch1), len2 = strlen(ch2);
    for (int i = 0; i < len1; ++i)
    {
        while (j >= 0 && ch2[j+1] != ch1[i]) j = nxt[j];
        if (ch2[j+1] == ch1[i]) j++;
        if (j+1 == len2)
        {
            cnt++;
            j = nxt[j];
        }
    }
    return cnt;
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%s", ch2);
        scanf("%s", ch1);
        getNext();
        printf("%d
", work());
    }

    return 0;
}