训练日志7 （7.25）

T1 匹配

　　水题。

　　KMP裸题。

　　hash完美AC。

　　我WA 0。

　　内心十分激动。

　　明显的KMP，但是板子没背会，于是yy：

　　

while (j<=la+lb+1)
{
	if (!i) nx[j++]=i++;
	else 
	{
		while (sa[i+1]!=sa[j] and i) i=nx[i];
		nx[j++]=i++;
	        if (i>la) i=nx[i];
	}
}

 　　狗屎。

　　唯一的好处是让我复习了一遍Hash和KMP。

　　处理最后一位b时注意去除回车和空格。（WA 9 根源）

　　小弟不才。

T2 回家

　　水题。

　　不过我不会 WA 10。

　　没打过点双，自己yy了一个无向图缩点，最后把点，缩成了一坨。

　　神奇的是这种超级超级超级错解竟然能够70 ，而我之加了一句话。

　　然后发现没法改了，开始撸正解。

　　学到了点双，收获不错。

　　点双+Dfs，AC，记得数组要往大里开，要把起点和终点除掉。

　　小弟不才。

　　

#include<cstdio>
#include<vector>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
#define mm(a) memset(a,0,sizeof(a))
#define HZOI using namespace std
HZOI;
const int MAXN=2e6+3;
struct node{
    int v,next;
}edge[MAXN<<2];
int T,n,m;
int tt,et,efirst[MAXN],first[MAXN],vv[MAXN<<2],nx[MAXN<<2];
int cnt,tot,tail,dfn[MAXN],low[MAXN],be[MAXN],vis[MAXN],stack[MAXN];
int iscut[MAXN],idcut[MAXN],oldid[MAXN];
int ans[MAXN],nu;
vector<int > vec[MAXN];
inline int read();
inline void Add(int ,int );
inline void NewAdd(int ,int );
void Tarjan(int ,int );
bool Dfs(int );
inline void Clear();
int main()
{
    T=read();
    while (T--)
    {
        Clear();
        n=read(); m=read();
        for (int i=1,x,y; i<=m; ++i)
        {
            x=read(); y=read();
            Add(x,y); Add(y,x);
        }
        Tarjan(1,1);
        if (!dfn[n]) {printf("0

");continue;}
        int num=cnt;
        for (int i=1; i<=n; ++i)
            if (iscut[i])
                idcut[i]=++num,oldid[num]=i;
        for (int i=1; i<=cnt; ++i)
            for (int j=0; j<vec[i].size(); ++j)
            {
                int x=vec[i][j];
                if (iscut[x])
                {
                    NewAdd(i,idcut[x]);
                    NewAdd(idcut[x],i);
                    be[x]=idcut[x];
                }
                else be[x]=i;
            }
        memset(vis,0,sizeof(vis));
        if (be[1]==be[n]) {printf("0

");continue;}
        Dfs(be[1]);
        sort(ans+1,ans+nu+1);
        printf("%d
",nu);
        for (int i=1; i<=nu; ++i)
            printf("%d ",ans[i]);
        puts("");
    }
    return 0;
}
bool Dfs(int k)
{
    if (be[n]==k) return 1;
    if (iscut[oldid[k]] and oldid[k]!=1) ans[++nu]=oldid[k];
    vis[k]=1;
    for (int i=efirst[k]; i; i=edge[i].next)
    {
        if (vis[edge[i].v]) continue;
        if (Dfs(edge[i].v)) return 1;
    }
    if (iscut[oldid[k]] and oldid[k]!=1) --nu;
    return 0;
}
void Tarjan(int k,int root)
{
    dfn[k]=low[k]=++tot;
    stack[++tail]=k;
    if (k==root and !first[k]) {vec[++cnt].push_back(k); return ;}
    int flag=0;
    for (int i=first[k]; i; i=nx[i])
    {
        int ver=vv[i];
        if (!dfn[ver])
        {
            Tarjan(ver,root);
            low[k]=min(low[k],low[ver]);
            if (low[ver]>=dfn[k])
            {
                ++flag;
                if (k!=root or flag>1) iscut[k]=1;
                ++cnt;
                int to;
                do
                {
                    to=stack[tail--];
                    vec[cnt].push_back(to);
                }while (to!=ver);
                vec[cnt].push_back(k);
            }
        }
        else low[k]=min(low[k],dfn[ver]);
    }
}
inline void Add(int u,int v)
{
    vv[++tt]=v; nx[tt]=first[u]; first[u]=tt;
}
inline void NewAdd(int u,int v)
{
    edge[++et].v=v; edge[et].next=efirst[u]; efirst[u]=et;
}
inline int read()
{
    int cc=0; char ch=getchar();
    while (ch<'0' or ch>'9') ch=getchar();
    while (ch>='0' and ch<='9') cc=(cc<<3)+(cc<<1)+(ch^48),ch=getchar();
    return cc;
}
inline void Clear()
{
    mm(efirst); mm(first);
    mm(dfn); mm(be);
    mm(iscut); mm(idcut); mm(oldid);
    for (int i=1; i<=cnt; ++i) vec[i].clear();
    cnt=tot=tail=tt=nu=et=0;
    return ;
}

　

T3 寿司

　　神仙题。

　　把环搞成一段序列，首尾相接，使他长度变为2n（环题的惯用套路）。

　　接下来就不是好想的了，我怎么可能看出来这玩意儿有***单调性？！

　　只要我们稍微思考一下，会发现一个很显然的性质：序列中存在一个断点，使它左边的点全移向左边，右边的全移向右边。

　　那么就接着会有一个更显然的性质：断点左边的0/1一定等于右边的0/1。

　　O（n²）：枚举断点暴力计算。

　　O（nlogn）（我的极限）：二分搜索断点，然后O（1）计算。

　　O（n）：说过这道题有一个神奇的单调性，我们把序列看成一个0/1串，我们使0移向序列两侧，只要我们的mid（断点）一直向右移动，左边的1的手机数量会越来越少，而右边的1越来越多，这说明0向左走的步数越来越少，于是断点会不断向右移动，这是我们便找到了这个单调性，线性平行O（n）复杂度。

　　这里给出一些巨佬的题解，留做借鉴：mikufun ，DeepInC 。

　　小弟不才。

#include<cstdio>
#include<iostream>
#include<cstring>
#define int long long
#define mm(a) memset(a,0,sizeof(a))
#define HZOI using namespace std
HZOI;
const int MAXLEN=3e6+3;
int T;
int ch[MAXLEN];
int lb[MAXLEN],rb[MAXLEN],lr[MAXLEN],rr[MAXLEN],sl[MAXLEN],sr[MAXLEN];
int l,r,mid;
inline int min(int a,int b) {return a<b?a:b;}
inline int Cal(int ,int ,int );
signed main()
{
    scanf("%lld",&T);
    while (T--)
    {
        mm(lb); mm(rb); mm(lr); mm(rr); mm(sl); mm(sr);
        int t=1;
        ch[t]=getchar();
        while (ch[t]!='B' and ch[t]!='R') ch[t]=getchar();
        while (ch[t]=='B' or ch[t]=='R') ch[++t]=getchar();
        --t;
        for (int i=t+1; i<=t*2; ++i) ch[i]=ch[i-t];
        t<<=1;
        lb[0]=lr[0]=sl[0]=0;
        for (int i=1; i<=t; ++i)
        {
            lb[i]=lb[i-1]; lr[i]=lr[i-1]; sl[i]=sl[i-1];
            if (ch[i]=='R') ++lr[i];
            else ++lb[i],sl[i]+=lr[i];
        }
        rb[t|1]=rr[t|1]=sr[t|1]=0;
        for (int i=t; i>=1; --i)
        {
            rb[i]=rb[i+1]; rr[i]=rr[i+1]; sr[i]=sr[i+1];
            if (ch[i]=='R') ++rr[i];
            else ++rb[i],sr[i]+=rr[i];
        }
        t>>=1; mid=1;
        int ans=0x7fffffffffffffff;
        for (int i=1; i<=t; ++i)
        {
            l=i,r=i+t-1;
            while(mid<i+t-1&&lb[mid]-lb[i-1]<=(lb[i+t-1]-lb[i-1])/2) mid++;
//            cout<<mid<<endl;
            ans=min(ans,Cal(l,mid,r));
//            cout<<"ans="<<ans<<endl;
        }
        printf("%lld
",ans);
    }
    return 0;
}
inline int Cal(int l,int mid,int r)
{
    return sl[mid-1]-sl[l-1]-(lb[mid-1]-lb[l-1])*lr[l-1]+sr[mid]-sr[r+1]-(rb[mid]-rb[r+1])*rr[r+1];
}

　　永不放弃。