我的板子2——字符串

#include<bits/bits/stdc++.h>
using namespace std;


/*
输入N ，表示有一个长为N的子串，接下来N行，每行输入ai 和ai个数，表示有ai个数，表示子串第i个字符为ai个数中的一个，也就是这个子串的正则式，然后输入一个主串，要求输出这个主串中包含的所有的子串。
// hdu 5972

#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define IOS ios::sync_with_stdio(false); cin.tie(0), cout.tie(0)
typedef long long LL;
using PII = pair<int, int>;
const int maxn = 5e6 + 5;
const int mod = 1e9 + 7;

bitset<1005> pos[10], ans;
char s[maxn];
bitset初始为文本串长度,pos初始化为各个字符出现的位置，0表示出现过,1表示未出现,最后判断ans[n-1]即可知道答案
int main(){
    IOS;
    int n, k, v;
    while(cin >> n){
        for(int i = 0; i <= 9; i++) pos[i].set();
        for(int i = 0; i < n; i++){
            cin >> k;
            while(k--){
                cin >> v;
                pos[v].reset(i);
            }
        }
        cin >> s;
        ans.set();
        for(int i = 0; s[i]; i++){
            ans <<= 1;
            ans |= pos[s[i] - '0'];
            if(!ans[n - 1]){
                char now = s[i + 1];
                s[i + 1] = '\0';
                cout << (s + i - n + 1) << endl;
                s[i + 1] = now;
            }
        }
    }
}
*/





/*
 KMP算法
//打印 s2 串在 s1 串的位置	洛谷 P3375
//输出：从小到大顺序输出s2在s1中出现的位置，最后一行输出|s2|个整数，第i个整数表示s2的长度为i的前缀的最长border长度
//border为s的一个非s本身的子串t,满足t即是s的前缀又是s的后缀
//next[i]表示S子串S[0,i]的真后缀与真前缀的最大公共前缀长度，同时也是该位置失配后跳转的位置
//next[i]表示长度为i的前缀的最长border长度
#include <bits/stdc++.h>
#define endl '\n'
#define IOS ios::sync_with_stdio(false); cin.tie(nullptr), cout.tie(nullptr)
using namespace std;
typedef long long LL;
const int maxn = 1e6 + 5;

char s1[maxn], s2[maxn];
int nxt[maxn], len1, len2;

inline void getnext(){
    nxt[0] = nxt[1] = 0;
    for(int i = 1, j; i < len2; i++){
        j = nxt[i];
        while(j && s2[i] != s2[j]) j = nxt[j];
        nxt[i + 1] = (s2[i] == s2[j] ? j + 1 : 0);
    }
}

int main(){
    IOS;
    cin >> s1 >> s2;
    len1 = strlen(s1), len2 = strlen(s2);
    getnext();
    for(int i = 0, j = 0; i < len1; i++){
        while(j && s1[i] != s2[j]) j = nxt[j];
        if(s1[i] == s2[j]) j++;
        if(j == len2){
            cout << i - len2 + 2 << endl;
            j = nxt[j];
        }
    }
    for(int i = 1; i <= len2; i++) cout << nxt[i] << " ";
}
*/

/*求最长长度的回文串的长度和数量
//SPOJ - MSUBSTR 最长长度的回文串的长度，和数量
#include <bits/stdc++.h>
#define endl '\n'
#define IOS ios::sync_with_stdio(false); cin.tie(nullptr), cout.tie(nullptr)
using namespace std;
typedef long long LL;
const int maxn = 1e4 + 5;

char s2[maxn], s[maxn];
int r[maxn], cnt;

int main(){
    IOS;
    int T;
    cin >> T;
    while(T--){
        cin >> s2;
        s[cnt = 0] = '~';
        for(int i = 0; s2[i]; i++){
            s[++cnt] = '|';
            s[++cnt] = s2[i];
        }
        s[++cnt] = '|';
        int mid = 0, rb = 0;
        int maxnum = 0, ans = 0;
        for(int t = 1; t <= cnt; t++){
            if(t < rb) r[t] = min(r[(mid << 1) - t], rb - t);
            else     r[t] = 1;
            while(t - r[t] > 0 && t + r[t] <= cnt && s[t - r[t]] == s[t + r[t]]) r[t]++;
            if(r[t] + t > rb) rb = r[t] + t, mid = t;
            if(r[t] > maxnum) maxnum = r[t], ans = 1;
            else if(r[t] == maxnum) ans++;
        }
        cout << maxnum - 1 << " " << ans << endl;
    }
}

*/

/*无重复字符的字长子串
//求不含重复字符的最长子串长度
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // 哈希集合，记录每个字符是否出现过
        unordered_set<char> occ;
        int n = s.size();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rk = -1, ans = 0;
        // 枚举左指针的位置，初始值隐性地表示为 -1
        for (int i = 0; i < n; ++i) {
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.erase(s[i - 1]);
            }
            while (rk + 1 < n && !occ.count(s[rk + 1])) {
                // 不断地移动右指针
                occ.insert(s[rk + 1]);
                ++rk;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = max(ans, rk - i + 1);
        }
        return ans;
    }
};
*/

/*LIS最长递增子序列DP解法
// 这里的最长递增子序列是允许中间跨越其他子序列的
#include<iostream>
#include<algorithm>
using namespace std;

int *arr;
int *dp;

// 经典问题 dp[i]的意思为以i为结尾的最长子序列为多少
int getResult(int n)
{
	dp[0] = 1;
	for (int i = 1; i < n; i++)
	{
		int cnt = 1;
		for (int j = i - 1; j >= 0; j--)
		{
			if (arr[i] > arr[j])
			{  // 保证递增
				cnt = max(cnt, dp[j] + 1);
			}
		}
		dp[i] = cnt;
	}
	int ans = 0;
	for (int i = 0; i < n; i++)
	{
		ans = max(ans, dp[i]);
	}
	return ans;
}

// 二分查找变体 找到第一个大于n的位置index
int BinarySearch(int *dp, int len, int n)
{
	int left = 1;
	int right = len;
	while (left < right)
	{
		int mid = (left + right) / 2;
		if (dp[mid] > n)
		{
			right = mid;
		}
		else
		{
			left = mid+1;
		}
	}
	return right;
}

// 优化的dp dp数组的最终下标为答案
int getResult1(int n)
{
	 dp[1] = arr[0];
	 int index = 1;
	 for (int i = 1; i < n; i++)
	 {
	 	if (arr[i] > dp[index])
	 	{
	 		// 更新index
	 		dp[++index] = arr[i];
		 }
		 else
		 {
		 	// 把dp数组中第一个大于n的数字替换为arr[i]
		 	int tempIndex = BinarySearch(dp, index, arr[i]);
		 	dp[tempIndex] = arr[i];
		 }
	 }
	 return index;
}



int main(){
	int n;
	while (cin >> n)
	{
		arr = new int[n];
		dp = new int[n+1];
		for (int i = 0; i < n; i++)
		{
			cin >> arr[i];
		}
		int ans = getResult1(n);
		cout << ans << endl;
		delete[] arr;
		delete[] dp;
	}
	return 0;
}

//Leetcode版本
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = (int)nums.size();
        if (n == 0) {
            return 0;
        }
        vector<int> dp(n, 0);
        for (int i = 0; i < n; ++i) {
            dp[i] = 1;
            for (int j = 0; j < i; ++j) {
                if (nums[j] < nums[i]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
        }
        return *max_element(dp.begin(), dp.end());
    }
};

*/

/*最长公共子序列
//LeetCode版本
class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length(), n = text2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            char c1 = text1.charAt(i - 1);
            for (int j = 1; j <= n; j++) {
                char c2 = text2.charAt(j - 1);
                if (c1 == c2) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }
}
*/

/*最长公共前缀
//LeetCode版本：先排序然后比较头尾
class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if(strs.empty()) return string();
        sort(strs.begin(), strs.end());
        string st = strs.front(), en = strs.back();
        int i, num = min(st.size(), en.size());
        for(i = 0; i < num && st[i] == en[i]; i ++);
        return string(st, 0, i);
    }
};
*/

/*最长回文子序列
//求长度
class Solution {
    public int longestPalindromeSubseq(String s) {
        int n = s.length();
        int[][] f = new int[n][n];
        for (int i = n - 1; i >= 0; i--) {
            f[i][i] = 1;
            for (int j = i + 1; j < n; j++) {
                if (s.charAt(i) == s.charAt(j)) {
                    f[i][j] = f[i + 1][j - 1] + 2;
                } else {
                    f[i][j] = Math.max(f[i + 1][j], f[i][j - 1]);
                }
            }
        }
        return f[0][n - 1];
    }
}
*/

/*最小编辑距离算法

是指两个字串之间，由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。一般来说，编辑距离越小，两个串的相似度越大。
int dp[1005][1005];     dp[i][j]表示表示A串从第0个字符开始到第i个字符和B串从第0个
字符开始到第j个字符，这两个字串的编辑距离。字符串的下标从1开始。
char a[1005],b[1005];   //a,b字符串从下标1开始

int EditDis()
{
    int len1 = strlen(a+1);
    int len2 = strlen(b+1);
    //初始化
    for(int i=1;i<=len1;i++)
        for(int j=1;j<=len2;j++)
            dp[i][j] = INF;
    for(int i=1;i<=len1;i++)
        dp[i][0] = i;
    for(int j=1;j<=len2;j++)
        dp[0][j] = j;
    for(int i=1;i<=len1;i++)
    {
        for(int j=1;j<=len2;j++)
        {
            int flag;
            if(a[i]==b[j])
                flag=0;
            else
                flag=1;
            dp[i][j]=min(dp[i-1][j]+1,min(dp[i][j-1]+1,dp[i-1][j-1]+flag));
            //dp[i-1][j]+1表示删掉字符串a最后一个字符a[i]
            //dp[i][j-1]+1表示给字符串添加b最后一个字符
            //dp[i-1][j-1]+flag表示改变,相同则不需操作次数,不同则需要,用flag记录
        }
    }
    return dp[len1][len2];
}
*/

 /*求字符串的排列
 class Solution {
public:
    vector<string> permutation(string s) {
        dfs(s, 0);
        return res;
    }
private:
    vector<string> res;
    void dfs(string s, int x) {
        if(x == s.size() - 1) {
            res.push_back(s);                       // 添加排列方案
            return;
        }
        set<int> st;
        for(int i = x; i < s.size(); i++) {
            if(st.find(s[i]) != st.end()) continue; // 重复，因此剪枝
            st.insert(s[i]);
            swap(s[i], s[x]);                       // 交换，将 s[i] 固定在第 x 位
            dfs(s, x + 1);                          // 开启固定第 x + 1 位字符
            swap(s[i], s[x]);                       // 恢复交换
        }
    }
};

 */

 /*最长不含重复字符的子字符串
 class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.size()<2)
        return s.empty()?0:1;
        int l=0,r=1,ans=0;
        unordered_set<char> Hash;
        Hash.insert(s.front());

        while(r<s.size())
        {
            if(Hash.count(s[r]))
            {
                ans=max(ans,r-l);
                while(Hash.count(s[r]))
                Hash.erase(s[l++]);
            }
            else
            Hash.insert(s[r++]);
        }
        return max(ans,r-l);
    }
};

 */

 /*求最小元素与最大元素的和小于或等于target的个数
 class Solution {
public:
    static constexpr int P = int(1E9) + 7;
    static constexpr int MAX_N = int(1E5) + 5;

    int f[MAX_N];

    void pretreatment() {
        f[0] = 1;
        for (int i = 1; i < MAX_N; ++i) {
            f[i] = (long long)f[i - 1] * 2 % P;
        }
    }

    int numSubseq(vector<int>& nums, int target) {
        pretreatment();

        sort(nums.begin(), nums.end());

        int ans = 0;
        for (int i = 0; i < nums.size() && nums[i] * 2 <= target; ++i) {
            int maxValue = target - nums[i];
            int pos = upper_bound(nums.begin(), nums.end(), maxValue) - nums.begin() - 1;
            int contribute = (pos >= i) ? f[pos - i] : 0;
            ans = (ans + contribute) % P;
        }

        return ans;
    }
};


 */

 /*
记录字典序最大子串的首字母的下标
class Solution {
public:
    string lastSubstring(string s) {
        int l = 0, r = 1, k = 0, n = s.size();
        while(r + k < n){
            if(s[l + k] == s[r + k]) k++;
            else if(s[l] < s[r + k]){
                l = r + k;
                r = l + 1;
                k = 0;
            }
            else if(s[l + k] < s[r + k]){
                l = r;
                r++;
                k = 0;
            }
            else{
                r++;
                k = 0;
            }
        }
        return s.substr(l);
    }
};


*/

/*AC自动机 Fail树
//有N个小写字母组成的模式串及一个文本串T。每个模式串可能在文本串中出现多次，找出哪些模式串在文本串中出现次数最多
// 洛谷 p3796
#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long LL;
const int maxn = 2e6 + 5;
const int lens = 2e4 + 5;
int cnt;
int tr[lens][26], isend[lens], fail[lens], id[lens], size[lens], head[lens], tol, maxone;
char mo[200][200], text[maxn];

struct node{
    int v, next;
}failtree[maxn];

inline void add(int u, int v){
    failtree[tol].v = v;
    failtree[tol].next = head[u];
    head[u] = tol++;
}

inline void dfs(int u){
    for(int k = head[u]; ~k; k = failtree[k].next){
        int v = failtree[k].v;
        dfs(v);
        size[u] += size[v];
    }
    if(isend[u])
        maxone = max(maxone, size[u]);
}

inline void insert(char s[], int no){
    int p = 0;
    for(int i = 0; s[i]; i++){
        int k = s[i] - 'a';
        if(!tr[p][k]) tr[p][k] = ++cnt;
        p = tr[p][k];
    }
    isend[p]++;
    id[no] = p;
}

inline void build(){
    queue<int> q;
    memset(fail, 0, sizeof(fail));
    for(int i = 0; i < 26; i++)if(tr[0][i])q.push(tr[0][i]);
    while(!q.empty()){
        int k = q.front();
        q.pop();
        for(int i = 0; i < 26; i++){
            if(tr[k][i]){
                fail[tr[k][i]] = tr[fail[k]][i];
                q.push(tr[k][i]);
            }else tr[k][i] = tr[fail[k]][i];
        }
    }
}

inline void init(){
    maxone = cnt = tol = 0;
    memset(size, 0, sizeof(size));
    memset(head, -1, sizeof(head));
    memset(tr, 0, sizeof(tr));
    memset(isend, 0, sizeof(isend));
    memset(fail, 0, sizeof(fail));
}

int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(false);
    int n;
    while(cin >> n){
        if(!n)break;
        init();
        for(int i = 1; i <= n; i++){
            cin >> mo[i];
            insert(mo[i], i);
        }
        build();
        cin >> text;
        for(int i = 0, p = 0; text[i]; i++){
            p = tr[p][text[i] - 'a'];
            size[p]++;
        }
        for(int i = 1; i <= cnt; i++) add(fail[i], i);
        dfs(0);
        cout << maxone << endl;
        for(int i = 1; i <= n; i++)
            if(size[id[i]] == maxone)
                cout << mo[i] << endl;
    }
}


*/


/*回文自动机
//定义s的一个子串的存在值为这个子串在s中出现的次数乘以这个子串的长度
//求所有回文子串中的最大存在值
// 洛谷 P3649
// 洛谷 P3649
#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long LL;
const int maxn = 3e5 + 5;
int sz, tol, last;
int len[maxn], ch[maxn][26], fail[maxn], cnt[maxn];
char s[maxn], tree[maxn];
//int sum[maxn];                // number of string that last is the end

inline int node(int lens){
    len[++sz] = lens;
    // fail[sz] = cnt[sz] = 0;
    // memset(ch[sz], 0, sizeof(ch[sz]));
    return sz;
}

inline void init(){
    // last = 0;
    // tol = 0;
    sz = -1;
    tree[0] = '$';
    node(0);
    node(-1);
    fail[0] = 1;                                                // the odd tree and even tree
}

inline int getfail(int x){
    while(tree[tol - len[x] - 1] != tree[tol]) x = fail[x];     // compare the char beside the string
    return x;
}

inline void insert(char c){
    tree[++tol] = c;
    int now = getfail(last), k = c - 'a';                       // now is the "bb" of the "abba", not the suffix
    if(!ch[now][k]){
        int x = node(len[now] + 2);                             // two char once time
        fail[x] = ch[getfail(fail[now])][k];
//        sum[x] = sum[fail[x]] + 1;
        ch[now][k] = x;
    }
    last = ch[now][k];
    cnt[last]++;
}

LL getans(){
    LL ans = 0;
    for(int i = sz; i >= 0; i--) cnt[fail[i]] += cnt[i];
    for(int i = 1; i <= sz; i++) ans = max(ans, (LL)len[i]*cnt[i]);
    return ans;
}

int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(false);
    init();
    cin >> s;
    for(int i = 0; s[i]; i++){
        insert(s[i]);
//        cout << sum[last] << " ";
    }
    cout << getans() << endl;
}

*/

/*后缀自动机
//求出S的所有出现次数不为1的子串的出现次数乘上该子串长度的最大值
// 洛谷 p3804
#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long LL;
const int maxn =  2e6 + 5;

char s[maxn];
int sz, last, cnt;               // sz = size
int head[maxn], size[maxn];
LL ans;

struct state{
    int len, link;
    int next[26];
}st[maxn];

struct node{
    int v, next;
}edge[maxn];

inline void add(int u, int v){
    edge[cnt].next = head[u];
    edge[cnt].v = v;
    head[u] = cnt++;
}

inline void init(){
    memset(head, -1, sizeof(head));
    st[0].len = 0;
    st[0].link = -1;
    sz = 0;
    last = 0;
    cnt = 0;
}


inline void extend(char ch){
    int now = ++sz, c = ch - 'a';
    st[now].len = st[last].len + 1;
    //pos[now] = st[last].len;     start position
    int p = last;
    while(~p && !st[p].next[c]){
        st[p].next[c] = now;
        p = st[p].link;
    }
    if(p == -1)
        st[now].link = 0;
    else{
        int q = st[p].next[c];
        if(st[p].len + 1 == st[q].len)
            st[now].link = q;
        else{
            int clone = ++sz;
            st[clone] = st[q];
            st[clone].len = st[p].len + 1;
            st[q].link = st[now].link = clone;
            while(~p && st[p].next[c] == q){
                st[p].next[c] = clone;
                p = st[p].link;
            }
        }
    }
    last = now;
    size[now]++;
}

inline void dfs(int u){
    for(int k = head[u]; ~k; k = edge[k].next){
        dfs(edge[k].v);
        size[u] += size[edge[k].v];
    }
    if(size[u] != 1) ans = max(ans, (LL)size[u]*st[u].len);
}

int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(false);
    cin >> s;
    init();
    for(int i = 0; s[i]; i++) extend(s[i]);
    for(int i = 1; i <= sz; i++) add(st[i].link, i);
    dfs(0);
    cout << ans;
}


*/

/*求第k大子串
#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long LL;
const int maxn =  1e6 + 5;

char s[maxn];
int sz, last, cnt;               // sz = size
int size[maxn], head[maxn], sum[maxn];

struct state{
    int len, link;
    int next[26];
}st[maxn];

struct node{
    int v, next;
}edge[maxn];

inline void add(int u, int v){
    edge[cnt].next = head[u];
    edge[cnt].v = v;
    head[u] = cnt++;
}

inline void init(){
    memset(head, -1, sizeof(head));
    st[0].len = 0;
    st[0].link = -1;
    sz = 0;
    last = 0;
}

inline void extend(int c){
    int now = ++sz;
    st[now].len = st[last].len + 1;
    int p = last;
    while(~p && !st[p].next[c]){
        st[p].next[c] = now;
        p = st[p].link;
    }
    if(p == -1)
        st[now].link = 0;
    else{
        int q = st[p].next[c];
        if(st[p].len + 1 == st[q].len)
            st[now].link = q;
        else{
            int clone = ++sz;
            st[clone] = st[q];
            st[clone].len = st[p].len + 1;
            st[q].link = st[now].link = clone;
            while(~p && st[p].next[c] == q){
                st[p].next[c] = clone;
                p = st[p].link;
            }
        }
    }
    last = now;
    size[now]++;
}

inline void dfs(int u){
    for(int k = head[u]; ~k; k = edge[k].next){
        dfs(edge[k].v);
        size[u] += size[edge[k].v];
    }
}

inline void dfs2(int u){
    if(sum[u]) return;
    sum[u] = size[u];
    for(int i = 0; i < 26; i++)
        if(st[u].next[i]){
            dfs2(st[u].next[i]);
            sum[u] += sum[st[u].next[i]];
        }
}

int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(false);
    init();
    int t, k;
    cin >> s;
    cin >> t >> k;
    for(int i = 0; s[i]; i++)
        extend(s[i] - 'a');
    if(t){
        for(int i = 1; i <= sz; i++)
            add(st[i].link, i);
        dfs(0);
        size[0] = 0;
    }else
        for(int i = 1; i <= sz; i++) size[i] = 1;
    dfs2(0);
    if(sum[0] < k) cout << -1 << endl;
    else{
        int now = 0, u;
        while(k > 0){
            for(int i = 0; i < 26; i++){
                u = st[now].next[i];
                if(u){
                    if(sum[u] < k)
                        k -= sum[u];        // 字典序小的总数量
                    else{
                        cout << char('a' + i);
                        k -= size[u];       //  以当前结点为结尾的最长串的数量
                        now = u;
                        break;
                    }
                }
            }
        }
    }
}
*/