国庆清北刷题冲刺班 Day5 下午

套路

文件名： road.cpp(pas) 时间限制： 1s 空间限制： 512MB
题目描述：
给出一个 N 个点的有向图，每个点的出度恰好为一。
现在希望给这 N 条边重定向，求图中不出现环的方案数（对 109 + 7 取模）。
输入格式：
第一行一个正整数 N。
第二行 N 个正整数 Xi，表示存在一条有向边从 i 指向 Xi。（老师本来这地方写错了，坑的我好惨）
输出格式：
一行，一个整数 Ans，表示定向后不出现环的方案数。
样例读入：
5
2 3 1 5 4
样例输出：
12
数据范围：
对于 30% 的数据，保证 N ⩽ 20
对于 60% 的数据，保证 N ⩽ 1000
对于 100% 的数据，保证 N ⩽ 10^5

分析：先Tarjan，对于每个环中的边，可以反转可以不反转，于是乎有
2^n中方案（假设有n条边），然后需要减去全部翻转和全部不翻转的两种情况，，多个环之间的方案相乘，最后在乘以 2 的树边次方【每条树边有两种和合法状态】。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<stack>
using namespace std;
#define MAXN 100005
#define LL long long
#define Mod 1000000007
int head[MAXN],n,m,input[MAXN],tot;
bool vis[MAXN],exist[MAXN];
struct Edge{ int to,next; }e[MAXN<<1];
int dfn[MAXN],low[MAXN],belong[MAXN],cur,visx,siz[MAXN];

inline void read(int &x){
    x=0; int f=1; char c=getchar();
    while(c>'9'||c<'0'){ if(c=='-')f=-1; c=getchar(); }
    while(c>='0'&&c<='9'){ x=x*10+c-'0'; c=getchar(); } x*=f;
}

void Add_Edge(int u,int v){
    e[++tot].to=v,e[tot].next=head[u],head[u]=tot;
}

stack<int> st;
void Tarjan(int u){
    dfn[u]=low[u]= ++visx;
    st.push(u),exist[u]=true;
    for(int i=head[u];i;i=e[i].next){
        int v=e[i].to;
        if(!dfn[v]){ Tarjan(v);low[u]=min(low[u],low[v]); }
        else if(exist[v]) low[u]=min(low[u],dfn[v]);
    }
    int x=-1;
    if(low[u]==dfn[u]){
        ++cur;
        do{
            x=st.top();st.pop(),siz[cur]++;
            belong[x]=cur;exist[x]=false;
        }while(x!=u);
    }
}

LL calc(int p){//2^p
    LL ret=1,a=2;
    while(p){
        if(p&1) ret = (ret * a) % Mod;
        a = (a * a) % Mod,p >>= 1;
    }
    return ret-2;
}

int main(int argc,char *argv[]){
    freopen("road.in","r",stdin);
    freopen("road.out","w",stdout);
    read(n);
    for(int x,i=1;i<=n;++i) read(x),Add_Edge(i,x);
    LL Ans = 1;int last = 1;
    for(int i=1;i<=n;++i)
        if(!dfn[i]){
            Tarjan(i);// 记得 一次Tarjan并不一定只  产生一个新的cur  这地方自己把自己坑了
            for(int j=last; j<=cur; ++j)
                if(siz[j] > 1) Ans = Ans * calc(siz[j]) % Mod;
                else Ans = Ans * 2 % Mod;//  树边 情况 
            last = cur + 1;
        }
    printf("%I64d\n",Ans);
    fclose(stdin); fclose(stdout);
    return 0;
}

exLCS

文件名： lcs.cpp(pas) 时间限制： 1s 空间限制： 512MB
题目描述：
给出两个仅有小写字母组成的字符串 str1 和 str2，试求出两个串的最长公共子序列。
公共子序列定义如下：
若有 a1 < a2 < · · · < ak 和 b1 < b2 < · · · < bk，满足
str1[ai] = str2[bi]; 8i 2 f1; 2; 3; · · · ; kg;
则称找到了一个长度为 k 的公共子序列。
输入格式：
第一行一个字符串 str1。
第二行一个字符串 str2。
输出格式：
一行，一个整数，表示 str1 与 str2 的最长公共子序列的长度。
样例读入：
abdcba
abafdsfa
样例输出：
4
样例解释：
如果字符串从 0 开始标号，可以验证 fang = f0; 1; 2; 5g， fbng = f0; 1; 4; 7g 是满足要求
的方案。
数据范围：
对于 10% 的数据，保证 jstr1j ⩽ 10; jstr2j ⩽ 10
对于 30% 的数据，保证 jstr1j ⩽ 20; jstr2j ⩽ 30
对于 60% 的数据，保证 jstr1j ⩽ 1000; jstr2j ⩽ 1000
对于 100% 的数据，保证 jstr1j ⩽ 1000; jstr2j ⩽ 10^6
说不清楚的来张图，哈哈

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 1010
#define MAXM 1000010
const int INF = 1e9;
char a[MAXN],b[MAXM];
int f[MAXN][MAXN],nxt[MAXM][26],n,m;

void solve() {
    f[0][1] = nxt[0][a[0] - 'a'];
    for(int i=0; i<=n; ++i) f[i][0] = -1;
    for(int i=0; i<n-1; ++i)
        for(int j=0; j<=n && f[i][j] < INF; ++j){
            f[i + 1][j] = min(f[i + 1][j], f[i][j]);
            if(j < n)
                f[i + 1][j + 1] = min(f[i + 1][j + 1],nxt[f[i][j] + 1][a[i + 1] - 'a']);
        }
}

int main(int argc,char *argv[]){
    freopen("lcs.in","r",stdin);
    freopen("lcs.out","w",stdout);
    scanf("%s%s", a, b);
    n = strlen(a), m = strlen(b);
    for(int i=0; i<=n; ++i)
        for(int j=0; j<=n; ++j) f[i][j] = INF;

    for(int i=0; i<26; ++i) nxt[m][i] = INF;

    for(int i=m-1; i>=0; --i){
        memcpy(nxt[i],nxt[i + 1],sizeof(nxt[i]));
        nxt[i][ b[i] - 'a' ] = i;
    }

    solve();
    int Ans = 0;
    for(int i=n; i; --i)
        if(f[n - 1][i] < INF) {
            Ans = i;
            break;
        }
    printf("%d\n", Ans);
    fclose(stdin); fclose(stdout);
    return 0;
}

考虑朴素 DP，记 f(i; j) 表示 str1 匹配到了第 i 位， str2 匹配到了第 j 位，的最长公共子序列长度，那么我们有如下递推关系：
f(i,j) = max{ f(i-1,j),f(i,j-1), f(i-1,j-1)+1[ If str1[i] = str2[j] ] }

该 DP 时间复杂度和空间复杂度均为 O(|str1| |str2|)。
由于 str2 较长，考虑改变 DP 的角度。
显然：最长公共子序列长度一定<= |str1|
记 g(i, j) 表示 str1 匹配到了第 i 位，最长公共子序列长度为 j 时， str2 可能匹配到的最左边的下标，那么我们有如下递推关系：
g(i,j)=min{ g(i-1,j),next( g(i-1,j-1) ,str1[i] ) }
其中， next(i， ch) 表示 str2 第 i 位后第一个字母 ch 出现的位置。
该 DP 的时间复杂度为 O(|str1|^2)，空间复杂度为 O(|str1|^2 + |str2| × 26)。

这种换维度的思想不错，非常值得学习

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 1010
#define MAXM 1000010
const int INF = 1e9;
char a[MAXN],b[MAXM];
int f[MAXN][MAXN],nxt[MAXM][26],n,m;

void solve() {
    f[0][1] = nxt[0][a[0] - 'a'];
    for(int i=0; i<=n; ++i) f[i][0] = -1;
    for(int i=0; i<n-1; ++i)
        for(int j=0; j<=n && f[i][j] < INF; ++j){
            f[i + 1][j] = min(f[i + 1][j], f[i][j]);
            if(j < n)
                f[i + 1][j + 1] = min(f[i + 1][j + 1],nxt[f[i][j] + 1][a[i + 1] - 'a']);
        }
}

int main(int argc,char *argv[]){
    freopen("lcs.in","r",stdin);
    freopen("lcs.out","w",stdout);
    scanf("%s%s", a, b);
    n = strlen(a), m = strlen(b);
    for(int i=0; i<=n; ++i)
        for(int j=0; j<=n; ++j) f[i][j] = INF;

    for(int i=0; i<26; ++i) nxt[m][i] = INF;

    for(int i=m-1; i>=0; --i){
        memcpy(nxt[i],nxt[i + 1],sizeof(nxt[i]));
        nxt[i][ b[i] - 'a' ] = i;
    }

    solve();
    int Ans = 0;
    for(int i=n; i; --i)
        if(f[n - 1][i] < INF) {
            Ans = i;
            break;
        }
    printf("%d\n", Ans);
    fclose(stdin); fclose(stdout);
    return 0;
}

关于T3

呵呵，很恶心的一个转魔方，题面还写错了，不想整理了，滚粗吧。