NOIP模拟53

T1：

　　分析题目性质，根据逻辑顺序，对于当前按钮位置对应的物品之起判断是否可以购买的作用，

于是发现，对于数量大于1的物品可以直接贪心使其数量变为1

　　考虑剩下的问题，比较显然为有限制的最优性问题，考虑如何转移，发现最优策略下，

f[i]对应的按钮一定要比i先按才会造成更多的贡献，否则若先按i，则f[i]为空，f[f[i]]无法造成贡献

因此可以用有向图建立这种联系，考虑那么问题转化为在有向图上存在最大路径，继续分析发现

若由i向f[i]连边形成的将是内向基环树，反之为外向

　　考虑基环树的常见解题方法为拆环进行树形DP，这种方法的限制为要么换大小并不大，要么

拆环对答案无影响，然而对于本题而言，环的大小无限制，拆环显然对最大路径产生影响，

那么若采用拆环DP的方式复杂度为O(S * n)（其中S为环大小），

　　考虑最大路径是否可以采用最大生成树的方式，众所周知，最值生成树的原理为贪心，在之前

说过，本题为有限制的最大路（每个点仅被经过一次），那么很显然贪心是错的，比如可以将一条

大边替换为几条较小边

　　那么考虑正解，本质上也是一种带悔贪心，考虑由于需要在基环树上找最大路径且每个点只能

经过一次，那么我们将问题进行划分，可以先求出对于每个点的出边（将边翻转即可建成外向基环树）

中选出最大值累积答案，发现这种决策下，当环上每个点都选择环上边作为出边时显然不符合条件

特盘即可

需要考虑的情况有基环树，树（可能带自环）

判环的几种方式：Dfs，Topsort，Tarjan

代码如下：

#include <bits/stdc++.h>
using namespace std;
#define I int
#define C char
#define B bool
#define V void
#define LL long long
#define P pair<I,I>
#define MP make_pair
#define fir first
#define sec second
const I N = 1e5 + 3;
I n,cnt,f[N],a[N],c[N],d[N],MA;
I tot,head[N],to[N],nxt[N],wgt[N],Outit[N],Init[N];
B jud,vis[N],top[N];
P item[N];
LL ans;
inline I read() {
    I x(0),y(1); C z(getchar());
    while (!isdigit(z)) { if (z == '-') y = -1; z = getchar(); }
    while ( isdigit(z))  x = x * 10 + (z ^ 48), z = getchar();
    return x * y;
}
inline I max (I a,I b) { return a > b ? a : b; }
inline V found (I x,I y,I z) {
    to[++tot] = y, nxt[tot] = head[x], wgt[tot] = z, head[x] = tot;
}
V topsort () {
    queue <I> q;
    for (I i(1);i <= n; ++ i) if (!Outit[i])
        q.push (i);
    while (!q.empty ()) {                                   //找环        
        I x(q.front ()); q.pop (); top[x] = 1;
        if (d[f[x]] - c[x] <= 0) continue;
        if (-- Outit[f[x]] == 0) q.push (f[x]);
    }
}
V Line (I x) {
    I tmp (0); vis[x] = 1;
    for (I i(head[x]),y(to[i]); i ;i = nxt[i],y = to[i])
        Line (y), tmp = max (tmp,wgt[i]);
    ans += tmp;
}
V Ring (I x) {
    I pos(0),tmp(0),val(0); vis[x] = 1;
    for (I i(head[x]),y(to[i]); i ;i = nxt[i],y = to[i]) {
        if (top[y]) tmp = max (tmp,wgt[i]), Line (y); else val = wgt[i]; if (!vis[y]) pos = y;
    }
    MA = max (MA,tmp - val); ans += tmp >= val ? (jud = 1, tmp) : val; if (pos) Ring (pos);
}
signed main () {
    n = read();
    for (I i(1);i <= n; ++ i) 
        f[i] = read(), c[i] = read(), d[i] = read(), a[i] = read();
    for (I i(1);i <= n; ++ i) if (d[f[i]] - c[i] > 0)
        item[++cnt].fir = c[i] - d[f[i]], item[cnt].sec = f[i];
    sort (item + 1,item + cnt + 1);                         //稳
    for (I i(1);i <= cnt; ++ i) 
        ans += 1ll * (a[item[i].sec] - 1) * -item[i].fir, a[item[i].sec] = 1;
    for (I i(1);i <= n; ++ i) if (d[f[i]] - c[i] > 0) {
        Outit[f[i]] ++ , Init[i] ++ ;
        found (f[i],i,d[f[i]] - c[i]);
    }
    topsort ();
    for (I i(1);i <= n; ++ i) if (!vis[i]) {
        if (!Init[i]) Line (i);
        if (!top[i]) {
            MA = INT_MIN, jud = 0, Ring (i);
            if (!jud && f[i] != i) ans += MA;               //判环
        } 
    }
    printf ("%lld\n",ans);
}

T2：

　　首先YY的做法：

考虑比较显然的思路为删串判断最终能否清空，然而是假的（并不完全假），考虑假的原因在于

可能存在一种字符串前后两部分相同，那么直接删可能会删除由前串+前串组成的串，那么回事得

两个后串无法进行匹配，那么考虑换一种删串方式，从中间（本质上来说是非首尾）删除，考虑

正确性，从中间删除使得该串只可能为前串后串进行搭配组成，即使存在非同一串的前后进行搭配

那么两串的两外一部分显然仍然可以搭配。考虑时间复杂度，若严格从中间进行删除，可以近似看作二分

（一般情况下为分治），那么考虑最多进行logn层，每层复杂度为n，考虑枚举长度+匹配串为n^2，

那么综合复杂度为O(Tn^3logn)，由于本题分治复杂度并不稳定，且复杂度较满，需要卡常+剪枝

（如果具备优秀的分治技巧并不需要卡）

　　考虑正解做法：
仍然枚举长度+匹配串，只是将判断方法转化DP判断，设f[i][j]代表i~j是否合法，区间DP，转移时

判断i~j中除匹配串外剩余部分是否能构成匹配串的前缀即可O(n^2)且严重跑不满

考虑卡常+剪枝+记忆化，快到起飞

代码如下（朴素版，基本无剪枝）：

#include <bits/stdc++.h>
using namespace std;
#define I int
#define C char
#define B bool
#define V void
I T,len,tot,gcd,buc[26];
C s[205],ans[205];
B dp[205][205];
inline I read() {
    I x(0),y(1); C z(getchar());
    while (!isdigit(z)) { if (z == '-') y = -1; z = getchar(); }
    while ( isdigit(z))  x = x * 10 + (z ^ 48), z = getchar();
    return x * y;
}
I GCD (I a,I b) { return !b ? a : GCD (b,a % b); }
inline V Init () {
    scanf ("%s",s + 1); len = strlen (s + 1);
    tot = gcd = 0, memset (buc,0,sizeof buc); 
}
inline B Check (I x) {
    for (I i(1);i <= len; ++ i) 
        for (I j(1);j <= len - i + 1; ++ j) {
            if (dp[j][j + i - 1] |= dp[j][j + i - 2] & (s[j + i - 1] == ans[(i - 1) % x + 1])) continue;
            for (I k(1);k * x <= i; ++ k) 
                if (dp[j][j + i - 1] |= dp[j][j + i - 1 - k * x] & dp[j + i - k * x][j + i - 1]) break;
        }
    return dp[1][len];
}
inline B Figure (I x) {
    for (I i(1);i <= len - x + 1; ++ i) {
        memcpy (ans + 1,s + i,x); memset (dp,0,sizeof dp); 
        dp[i][i + x - 1] = 1; for (I j(1);j <= len - x + 1; ++ j) dp[j][j] = (s[j] == s[i]);
        if (Check (x)) { ans[x + 1] = 0; printf ("%s\n",ans + 1); return true; }
    }
    return false;
}
signed main () {
    T = read();
    while (T -- ) { Init ();
        for (I i(1);i <= len; ++ i) buc[s[i] - 'a'] ++ ;
        for (I i(0);i <   26; ++ i) if (buc[i]) gcd = GCD (buc[i],gcd);
        for (I i(0);i <   26; ++ i) if (buc[i]) tot += (buc[i] /= gcd);
        for (I i(1);i <= len; ++ i)
          if (i % tot == 0 && len % i == 0 && Figure (i)) break;
    }
}