TZOJ 挑战题库随机训练02

点击题号跳转

原H题不存在，所以只有9题

A5381    B5822    C1157   D5151   E5133
F1369    G4170    H4733   I1147

A.C++实验：STL之search回到顶部

题意

STL中的search函数，判断一个序列是否是另一个序列的子序列

题解

STL search函数的使用，复杂度O(n^2)

PS：过气算法了，详情见KMP

代码

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

void Check(vector<int> vec1,vector<int> vec2){
    vector<int>::iterator iter1;
    iter1=search(vec1.begin(),vec1.end(),vec2.begin(),vec2.end());
    if(iter1!=vec1.end())
        cout<<iter1-vec1.begin()+1<<" "<<iter1-vec1.begin()+vec2.size()<<endl;
    else
        cout<<"None"<<endl;
}

B.程序自动分析回到顶部

题意

n([1,10^5])个约束，i,j([1,10^9]),e=1代表xi=xj，e=0代表xi!=xj，问是否存在n个约束的满足的情况

题解

由于没有先后关系，所以把1全部拿出来，显然一定满足，我们用并查集把i，j都连起来

最后判断所有的0是否都满足

由于i，j范围很大，并查集内存不够

所以需要离散化，类似于哈希，复杂度O(nlogn)

PS：原题没给数据范围，感人连WAn次

代码

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

const int N=1e5+5;
struct node{
    int a,b,c;
    bool operator<(const node &d)const{
        return c>d.c;
    }
}a[N];
int d[N*2],f[N*2];
int find(int x){
    return f[x]==x?x:f[x]=find(f[x]);
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n,tot=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%d%d%d",&a[i].a,&a[i].b,&a[i].c);
            d[++tot]=a[i].a;
            d[++tot]=a[i].b;
        }
        sort(d+1,d+1+tot);
        int sz=unique(d+1,d+1+tot)-d-1;
        for(int i=1;i<=n;i++){
            a[i].a=lower_bound(d+1,d+1+sz,a[i].a)-d;
            a[i].b=lower_bound(d+1,d+1+sz,a[i].b)-d;
        }
        for(int i=1;i<=sz;i++)f[i]=i;
        int flag=1;
        sort(a+1,a+1+n);
        for(int i=1;i<=n;i++){
            int fa=find(a[i].a);
            int fb=find(a[i].b);
            if(a[i].c){
                f[fa]=fb;
            }else if(fa==fb){
                flag=0;break;
            }
        }
        printf("%s
",flag?"YES":"NO");
    }
    return 0;
}

C.Highway回到顶部

题意

高速公路(0,0)->(0,L)，n个村庄(x,y)，要求造最少的高速出口使得每个村庄距离最近的出口距离<=D，保证有解

题解

保证有解，那么以n个村庄为圆心，和y=0相交于xl和xr，我们令xl<0时xl=0，xr>L时xr=L，不影响解

那么问题就变成区间选点问题

按右端点从小到大排序，再按左端点从大到小排序

维护一个右端点r，如果r<a[i].l那么r=a[i].r，个数+1，复杂度O(nlogn)

PS：题目也太难读了

代码

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

const int N=1e5+5;
struct node{
    double l,r;
    bool operator<(const node &d)const{
        return r<d.r||(r==d.r&&l>d.l);
    }
}a[N];
int main(){
    int l,d;
    while(cin>>l>>d){
        int n;
        cin>>n;
        for(int i=0;i<n;i++){
            double x,y;
            cin>>x>>y;
            a[i].l=x-sqrt(d*d-y*y);
            a[i].r=x+sqrt(d*d-y*y);
            if(a[i].l<0)a[i].l=0;
            if(a[i].r>l)a[i].r=l;
        }
        sort(a,a+n);
        double val=a[0].r;
        int ans=1;
        for(int i=1;i<n;i++){
            if(val<a[i].l){
                ans++;
                val=a[i].r;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

D.FQ 的气球回到顶部

题意

n([1,10^12])个气球排成一排，有m([1,10^5])种颜色，要求相邻两个颜色不同，并且k([1,2000])个气球颜色相同

题解

首先把k个气球按小到大排序，下标1开始

那么a[1]前和a[k]后的情况比较好考虑

m*(m-1)^(a[1]-1+n-a[k])，表示a[1]和a[k]有m种选择，其余点(m-1)种选择

然后就是考虑相邻的a[i]和a[i-1]的个数

由于a[i]和a[i-1]的颜色必须相同，所以把两个点看成一个点，然后就变成了一个环

设Fn表示放n个珠子的方案数，那么可以分成两种情况

1.考虑在n-1个珠子里插入一个珠子，方案数是(m-2)*Fn-1

2.考虑把n-2个珠子其中一个珠子分成两份并且在中间插入一个珠子，方案数是(m-1)*Fn-2

综合考虑为Fn=(m-1)*Fn-2+(m-2)*Fn-1，由于n很大，用矩阵快速幂求

F1=m，F2=m*(m-1)，F3=需要特殊考虑，情况2不合法，所以(m-2)*F2

优化常数：由于Fn=(m-1)*Fn-2+(m-2)*Fn-1是一个二阶常数递推式，可以解得通项公式Fn=(m-1)^n+(-1)^n*(m-1)

最后，由于我们把每个相邻的个数求出来，最后乘起来，还需要除m^(k-1)把固定相同的排除掉

细节：当k=0时，m*(m-1)^(n-1)种方案

复杂度O(k2^3logn)，优化常数做法变成O(klogn)

PS：暴躁詹老哥

代码

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

#define LL long long

const int P=1e9+7;
int k;
LL n,m,a[2005],f[4];
struct mat{
    LL a[2][2];
    mat(){
        memset(a,0,sizeof a);
    }
    mat operator*(const mat &b)const{
        mat c;
        for(int i=0;i<2;i++)
            for(int j=0;j<2;j++)
                for(int k=0;k<2;k++)
                    c.a[i][j]=(c.a[i][j]+a[i][k]*b.a[k][j]%P)%P;
        return c;
    }
};
mat quick_mat(mat a,LL b){
    mat ans;
    for(int i=0;i<2;i++)ans.a[i][i]=1;
    while(b){
        if(b&1)ans=ans*a;
        a=a*a;
        b>>=1;
    }
    return ans;
}
LL quick_LL(LL a,LL b){
    LL ans=1;
    while(b){
        if(b&1)ans=ans*a%P;
        a=a*a%P;
        b>>=1;
    }
    return ans;
}
LL solve_mat(LL len){
    if(len<=3)return f[len];
    mat ans;
    ans.a[0][0]=m-2;
    ans.a[1][0]=m-1;
    ans.a[0][1]=1;
    ans=quick_mat(ans,len-3);
    //for(int i=0;i<2;i++,printf("
"))
    //    for(int j=0;j<2;j++)
    //        printf("%lld ",ans.a[i][j]);
    //puts("");
    return (f[3]*ans.a[0][0]%P+f[2]*ans.a[1][0]%P)%P;
}
LL solve(){
    //1 1 0
    if(n==1)return m;
    if(m==1)return 0;
    if(k==0)return m*quick_LL(m-1,n-1)%P;
    for(int i=2;i<=k;i++)if(a[i]-a[i-1]==1)return 0;
    //两端
    LL ans=m*quick_LL(m-1,a[1]-1+n-a[k])%P;
    for(int i=2;i<=k;i++){
        LL val=solve_mat(a[i]-a[i-1]);
        //printf("i=%d %lld
",i,val);
        ans=ans*val%P;
    }
    //把固定相同的排除掉
    ans=ans*quick_LL(quick_LL(m,k-1),P-2)%P;
    return ans;
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%lld%lld%d",&n,&m,&k);
        for(int i=1;i<=k;i++)scanf("%lld",&a[i]);
        sort(a+1,a+1+k);
        f[1]=m,f[2]=m*(m-1)%P,f[3]=(m-2)*f[2]%P;
        printf("%lld
",solve());
    }
    return 0;
}

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N=2005;
const int MD=1e9+7;
ll b[N],n;
int m,k;
int quick_pow(int x,ll y) {
    int ans=1;
    while(y) {
        if(y&1) ans=1LL*ans*x%MD;
        y>>=1;
        x=1LL*x*x%MD;
    }
    return ans;
}
int gao(ll x) {
    return (quick_pow(m-1,x)+(x&1?-m+1:m-1)+MD)%MD;
}
int cal() {
    if(n==1) return m;
    if(m==1) return 0;
    if(k==0) return 1LL*m*quick_pow(m-1,n-1)%MD;
    for(int i=1;i<k;i++) {
        if(b[i]-b[i-1]==1) return 0;
    }
    int ans=1LL*m*quick_pow(m-1,b[0]-1+n-b[k-1])%MD;
    for(int i=1;i<k;i++) {
        ans=1LL*ans*gao(b[i]-b[i-1])%MD;
    }
    return 1LL*ans*quick_pow(quick_pow(m,k-1),MD-2)%MD;
}
int main() {
    //freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--) {
        scanf("%lld%d%d",&n,&m,&k);
        for(int i=0;i<k;i++) {
            scanf("%lld",&b[i]);
        }
        sort(b,b+k);
        printf("%d
",cal());
    }
    return 0;
}

E.U的爱慕者回到顶部

题意

小明的悄悄话长度为N（5<=N<=100）必须按顺序输出，先从上到下n1个字符，再从左到右n2个字符，再从下到上n3个字符

必须保证n1=n3=max{ k | k <= n2 && 3 <= n2 <= N },n1 + n2 + n3 - 2 = N

题解

式子看不懂？没关系

直接枚举k，找一个最大的满足的就行

求出n1，n2，n3

代码

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

int main(){
    string s;
    cin>>s;
    int sz=s.size();
    int n1=0,n2=0;
    for(int kn1=1;kn1<=sz;kn1++){
        int kn2=sz+2-kn1-kn1;
        if(kn1<=kn2){
            n1=kn1;n2=kn2;
        }
    }
    // printf("n1=%d n2=%d n3=%d
",n1,n2,n1);
    int pl=0,pr=sz-1;
    for(int i=0;i<n1;i++){
        printf("%c",s[pl++]);
        if(i<n1-1)for(int j=0;j<n2-2;j++)printf(" ");
        else{
            for(int j=pl;j<pr;j++)printf("%c",s[j]);
        }
        printf("%c",s[pr--]);
        puts("");
    }
    return 0;
}

F.求绝对值回到顶部

题意

求实数的绝对值

题解

fabs(x)，复杂度O(1)

代码

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

int main(){
    double c;
    while(scanf("%lf",&c)!=EOF){
        printf("%.2f
",fabs(c));
    }
    return 0;
}

G.The Longest Sequence回到顶部

题意

Mirko必须找到最长的不同区间序列，以使序列中的每个区间都在集合中，并且每个区间都包含序列中的后续区间。

编写一个找到最长序列的程序

N([1,100000])，间隔A，B([1,1000000])

题解

区间按左端点从小到大，再按右端点从大到小

相当于左端点不用考虑，只考虑右端点，倒过来做一个最长上升子序列

然后发现如果只记录值，会导致左端点乱掉，WA掉

复杂度O(nlogn)

代码

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

const int N=1e5+5;
struct node{
    int l,r;
    bool operator<(const node &d)const{
        return l<d.l||(l==d.l&&r>d.r);
    }
}a[N];
int d[N],did[N],tot,pre[N];
int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d%d",&a[i].l,&a[i].r);
    }
    sort(a,a+n);
    //for(int i=0;i<n;i++)
        //printf("%d %d
",a[i].l,a[i].r);
    for(int i=n-1;i>=0;i--){
        if(tot==0||a[i].r>=d[tot-1]){
            pre[i]=(tot==0?-1:did[tot-1]);did[tot]=i;d[tot++]=a[i].r;
        }else{
            int pos=upper_bound(d,d+tot,a[i].r)-d;
            //printf("pos=%d
",pos);
            d[pos]=a[i].r;did[pos]=i;pre[i]=(pos==0?-1:did[pos-1]);
        }
        //printf("i=%d put=%d {%d,%d} %d tot=%d
",i,pre[i],a[i].l,a[i].r,pre[i],tot);
        //puts("");
    }
    printf("%d
",tot);
    for(int i=did[tot-1];i>-1;i=pre[i]){
        printf("%d %d
",a[i].l,a[i].r);
    }
    return 0;
}
/*
10
1 8
1 9
2 8
3 9
1 50
1 8
5 9
2 10
2 100
2 5
*/

H.等边字符三角形回到顶部

题意

N*N([1,256])的图，求等边三角形个数

题解

维护一个前缀和表示i,j前有几个连续的'#'

枚举每个'#'按照前缀和求出所有个数

PS：感谢学弟指出

假算法：看似复杂度O(n^4)不行

仔细算一下，有很多优化的小地方，详情见代码

当256*256个'#'时达到最坏复杂度，经打表得到O(134209536≈1.3e8)爬过

代码

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

int pre[260][260];
char G[260][260];
int main(){
    int n;
    while(scanf("%d",&n)!=EOF){
        for(int i=1;i<=n;i++)scanf("%s",G[i]+1);
        // for(int i=1;i<=n;i++)
        //     for(int j=1;j<=n;j++)
        //         G[i][j]='#';
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++){
                if(G[i][j]=='.')pre[i][j]=0;
                else pre[i][j]=pre[i][j-1]+1;
            }
        int ans=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++){
                if(G[i][j]=='.')continue;
                for(int x=0;i+x<=n&&j+x<=n&&2*x+1<=n&&x<=n-i;x++)
                    if(pre[i+x][j+x]>=2*x+1)
                        ans++;
                    else break;
            }
        printf("%d
",ans);
    }
    return 0;
}

I.All Discs Considered回到顶部

题意

两张DVD，1张里有D1个软件，1张里有D2个软件，([1,50000])，D个约束([1,100000])，表示a软件要在b软件前安装，CD驱动器一次只能由1张DVD，问至少需要替换几次，一开始放进去和最后拿出来都算一次

题解

如果我们知道第一次放进去的是哪张DVD

按照拓扑排序，把改DVD所有软件度数为的0的拿出来，换DVD这样操作，复杂度O(n)

代码

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

const int N=1e5+5;
vector<int>G[N];
stack<int>st[2];
int d[2][N];
int main(){
    int n1,n2,D,x,y;
    while(scanf("%d%d%d",&n1,&n2,&D),n1||n2||D){
        int n=n1+n2;
        for(int i=1;i<=n;i++)G[i].clear(),d[0][i]=d[1][i]=0;
        for(int i=1;i<=D;i++){
            scanf("%d%d",&x,&y);
            if(x<=n1&&y<=n1);
            else if(x>n1&&y>n1);
            else{
                //printf("%d->%d
",x,y);
                G[x].push_back(y);
                d[0][y]++,d[1][y]++;
            }
        }
        int ans=1,minn=1e9;
        //DVD1
        int als=0;
        int p=0;
        for(int i=1;i<=n;i++)
            if(d[0][i]==0)
                st[i<=n1?0:1].push(i);
        while(1){
            while(!st[p].empty()){
                als++;
                int u=st[p].top();st[p].pop();
                for(int i=0;i<G[u].size();i++){
                    int v=G[u][i];
                    if(--d[0][v]==0)
                        st[v<=n1?0:1].push(v);
                }
            }
            if(als==n)break;
            ans++;
            p=1-p;
        }
        //printf("1 = %d
",ans+1);
        minn=min(ans+1,minn);
        while(!st[0].empty())st[0].pop();
        while(!st[1].empty())st[1].pop();
        p=1;
        ans=1;als=0;
        for(int i=1;i<=n;i++)
            if(d[1][i]==0)
                st[i<=n1?0:1].push(i);
        while(1){
            while(!st[p].empty()){
                als++;
                int u=st[p].top();st[p].pop();
                for(int i=0;i<G[u].size();i++){
                    int v=G[u][i];
                    if(--d[1][v]==0)
                        st[v<=n1?0:1].push(v);
                }
            }
            if(als==n)break;
            ans++;
            p=1-p;
        }
        while(!st[0].empty())st[0].pop();
        while(!st[1].empty())st[1].pop();
        //printf("2 = %d
",ans+1);
        minn=min(ans+1,minn);
        printf("%d
",minn);
    }
    return 0;
}