【纪中受难记】——Day10：逐渐自闭

只写了一道题，结果可想而知。

爆零。

---

1035. 粉刷匠 (Standard IO)

Time Limits: 5000 ms  Memory Limits: 65536 KB  Detailed Limits  

Goto ProblemSet

Description

windy有 N 条木板需要被粉刷。
每条木板被分为 M 个格子。
每个格子要被刷成红色或蓝色。
windy每次粉刷，只能选择一条木板上一段连续的格子，然后涂上一种颜色。
每个格子最多只能被粉刷一次。
如果windy只能粉刷 T 次，他最多能正确粉刷多少格子？
一个格子如果未被粉刷或者被粉刷错颜色，就算错误粉刷。

 

Input

第一行包含三个整数，N M T。
接下来有N行，每行一个长度为M的字符串，'0'表示红色，'1'表示蓝色。

Output

输出一个整数，表示最多能正确粉刷的格子数。

 

Sample Input

3 6 3
111111
000000
001100

Sample Output

16

 

Data Constraint

 

 

Hint

100%的数据，满足 1 <= N,M <= 50 ； 0 <= T <= 2500 。

 本题使用动态规划解决。

设sum[i][j]表示第i行中1~j的蓝色格子数，则j-sum[i][j]为红色格子数。

设g[i][j][k]表示i行中刷j次涂了1~k格的最大收益，则

考虑在q+1~k之间，

蓝色格子数为sum[i][k]-sum[i][q],

红色格子数为k-q-(sum[i][k]-sum[i][q]),

所以状态转移为：

g[i][j][k]=g[i][j-1][q]+max(sum[i][k]-sum[i][q]，k-q-(sum[i][k]-sum[i][q]))，

则每行收益为g[i][j][m],k为粉刷次数。

所以可以转化成一个背包问题解决。

#include<bits/stdc++.h>
using namespace std;
const int N=55;
int n,m,t;
int sum[N][N],g[N][N*N][N],f[N][N*N];
int main(){
    scanf("%d%d%d",&n,&m,&t);
    char c[500];
    for(int i=1;i<=n;i++){
        cin>>c;
        for(int j=1;j<=m;j++){
            if(c[j-1]=='1') sum[i][j]=sum[i][j-1]+1;
            else sum[i][j]=sum[i][j-1];
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            for(int k=1;k<=m;k++){
                for(int q=j-1;q<k;q++){
                    int tm=max(sum[i][k]-sum[i][q],k-q-(sum[i][k]-sum[i][q]));
                    g[i][j][k]=max(g[i][j][k],g[i][j-1][q]+tm);
                }
            }
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=t;j++){
            for(int k=0;k<=min(j,m);k++){
                f[i][j]=max(f[i][j],f[i-1][j-k]+g[i][k][m]);
            }
        }
    }
    int ans=0;
    for(int i=1;i<=t;i++){
        ans=max(f[n][i],ans);
    }
    printf("%d",ans);
//    for(int i=1;i<=n;i++){
//        for(int j=1;j<=m;j++){
//            printf("%d ",sum[i][j]);
//        }
//        cout<<endl;
//    }
    return 0;
}

---

1036. 迷路 (Standard IO)

Time Limits: 1000 ms  Memory Limits: 65536 KB  Detailed Limits  

Goto ProblemSet

Description

windy在有向图中迷路了。
该有向图有 N 个节点，windy从节点 0 出发，他必须恰好在 T 时刻到达节点 N-1。
现在给出该有向图，你能告诉windy总共有多少种不同的路径吗？
注意：windy不能在某个节点逗留，且通过某有向边的时间严格为给定的时间。

 

Input

第一行包含两个整数，N T。
接下来有 N 行，每行一个长度为 N 的字符串。
第i行第j列为'0'表示从节点i到节点j没有边。
为'1'到'9'表示从节点i到节点j需要耗费的时间。

Output

输出一个整数，可能的路径数，这个数可能很大，只需输出这个数除以2009的余数。

 

Sample Input

2 2
11
00

Sample Output

1

 

Data Constraint

 

 

Hint

100%的数据，满足 2 <= N <= 10 ； 1 <= T <= 1000000000 。

 送分题，对于一个点，我们可以将它拆成9个点，相应的矩阵变成9*n长度，对于一条边(u,v)，我们可以先处理出u到u后面8个节点的路径，每当一条边连通，相当于将缺少的最后一条边补上，这条边才算真正连通，（设置中间那些节点对答案并无影响）接着就可以矩阵乘法了。

#include<bits/stdc++.h>
using namespace std;
const int N=100;
const int mod=2009;
int n,t;
int cnt,x;
struct matrix{
    int a[N][N];
    void Empty(){
        memset(a,0,sizeof(a));
    }
    void One(){
        Empty();
        for(int i=1;i<=cnt;i++) a[i][i]=1; 
    }
    matrix operator *(matrix b){
        matrix tmp;
        tmp.Empty();
        for(int i=1;i<=cnt;i++){
            for(int j=1;j<=cnt;j++){
                for(int q=1;q<=cnt;q++){
                    tmp.a[i][j]+=(a[i][q]*b.a[q][j])%mod;
                    tmp.a[i][j]%=mod;
                }
            }
        }
        return tmp;
    }
    void out(){
        for(int i=1;i<=cnt;i++){
            for(int j=1;j<=cnt;j++){
                printf("%d ",a[i][j]);
            }
            printf("\n");
        }
    }
}res,ans;
void matrix_pow(int Q){
    ans.One();
    while(Q){
        if(Q&1){
            ans=ans*res;
        }
        res=res*res;
        Q>>=1;
    }
}
int pos(int a1,int a2){
    return a1+a2*n;
}
int main(){
    freopen("ans.txt","w",stdout);
    scanf("%d%d",&n,&t);
    res.Empty();
    cnt=n*9;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=8;j++){
            res.a[pos(i,j)][pos(i,j-1)]=1;
        }
        for(int j=1;j<=n;j++){
            scanf("%1d",&x);
            res.a[i][pos(j,x-1)]=1;
        }
    }
    res.out();
    matrix_pow(t);
    printf("%d",ans.a[1][n]);
    return 0;
}

---

1038. 游戏 (Standard IO)

Time Limits: 1000 ms  Memory Limits: 65536 KB  Detailed Limits  

Goto ProblemSet

Description

windy学会了一种游戏。 对于1到N这N个数字，都有唯一且不同的1到N的数字与之对应。 最开始windy把数字按顺序1，2，3，……，N写一排在纸上。 然后再在这一排下面写上它们对应的数字。 然后又在新的一排下面写上它们对应的数字。 如此反复，直到序列再次变为1，2，3，……，N。 如： 1 2 3 4 5 6 对应的关系为 1->2 2->3 3->1 4->5 5->4 6->6 windy的操作如下

1 2 3 4 5 6

2 3 1 5 4 6

3 1 2 4 5 6

12 3 5 4 6

2 3 1 4 5 6

3 1 2 5 4 6

1 2 3 4 5 6

这时，我们就有若干排1到N的排列，上例中有7排。 现在windy想知道，对于所有可能的对应关系，有多少种可能的排数。

 

Input

一个整数，N。

Output

一个整数，可能的排数。

 

Sample Input

3

Sample Output

3

 

Data Constraint

 

 

Hint

100%的数据，满足 1 <= N <= 1000 。

这题需要一点点思考。

根据题意，我们发现给的变换中有“环”出现，比如1->2,2->3,3->1构成一个三元环，因此，排数就等于所有环的最小公倍数+1。

考虑到长度为1并不构成环，对题目没有影响，而出现两个含有倍数关系的环，实质可以拆成两个不同质数，但如果出现指数关系，公倍数就是大的那个，因此用背包模型来解决。

我们先筛出质数表，n为背包容量，每个质数及其指数倍为物品，数的大小为物品的体积，求方案数即可。

注意开长整型。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=1010;
bool check[N];
ll cnt,p[N],n,ans;
ll f[N];
void Eus(ll n){
    check[0]=check[1]=1;
    for(int i=1;i<=n;i++){
        if(!check[i]) p[++cnt]=i;
        for(int j=1;j<=cnt;j++){
            if(i*p[j]>n) break;
            check[i*p[j]]=1;
            if(i%p[j]==0) break;
        }
    }
    
}
int main(){
    scanf("%lld",&n);
    Eus(n);
    f[0]=1;
    for(ll i=1;i<=cnt;i++){
        for(ll j=n;j>=p[i];j--){
            for(ll k=p[i];k<=j;k*=p[i]){
                f[j]+=f[j-k];
            }
        }
    }
    ans=0;
    for(int i=0;i<=n;i++) ans+=f[i];
    printf("%lld",ans);
    return 0;
}

---

1039. windy数 (Standard IO)

Time Limits: 1000 ms  Memory Limits: 65536 KB  Detailed Limits  

Goto ProblemSet

Description

windy定义了一种windy数。
不含前导零且相邻两个数字之差至少为2的正整数被称为windy数。
windy想知道，在A和B之间，包括A和B，总共有多少个windy数？

 

Input

两个整数，A B。

Output

一个整数，表示A~B中有多少个windy数。

 

Sample Input

1 10

Sample Output

9

 

Data Constraint

 

 

Hint

100%的数据，满足 1 <= A <= B <= 2000000000 。

 

数位dp板子，可惜我太辣鸡了，没学过。

学了之后发现好简单。

设f[i][j]表示第i位填j的windy数数量。

先递推出来，然后处理问题。

我们只要分别求出1~a与1~b的windy数数量再相减即可。

引用：

y2823774827y巨佬的题解

将数字分为三个部分，一个是长度不为len的部分，只要差大于等于2随便填，一个是有len位但是最高位不到len位数字的部分，一个是有len位且最高位为len的数字，但次位尽量往高位贴的部分，因为答案包括边界，所以是solve(r+1)-solve(l)。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a,b;
ll f[15][10];
ll num[20];
ll solve(ll x){
    memset(num,0,sizeof(num));
    ll len=0,ans=0;
    while(x){
        num[++len]=x%10;
        x/=10;
    }
    for(ll i=1;i<len;i++){
        for(ll j=1;j<=9;j++){
            ans+=f[i][j];
        }
    }
    for(ll i=1;i<num[len];i++) ans+=f[len][i];
    for(ll i=len-1;i>=1;i--){
        for(ll j=0;j<num[i];j++){
            if(abs(j-num[i+1])>=2) ans+=f[i][j];
        }
        if(abs(num[i]-num[i+1])<2) break;
    }
    return ans;
}
int main(){
    scanf("%lld%lld",&a,&b);
    for(ll i=0;i<=9;i++) f[1][i]=1;
    for(ll i=2;i<=10;i++){
        for(ll j=0;j<=9;j++){
            for(ll k=0;k<=9;k++){
                if(abs(j-k)>=2) f[i][j]+=f[i-1][k];
            }
        }
    }
    printf("%lld",solve(b+1)-solve(a));
    return 0;
}

---

 总结：知识要扎实的学习。