ACM预备队-大一下学期week(1)集训

1. 2023/3/15：

1.P8605 [蓝桥杯 2013 国 AC] 网络寻路（同学问的，自己补的）

题目链接：P8605 [蓝桥杯 2013 国 AC] 网络寻路 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

分析：我们的做法是记录所有点的度，然后枚举一个点所有相连接的点，他们之间的合法路径的总条数为：
(d[i]-1)*（d[j]-1)，减1是因为减掉了两个点之间相连的边。

#include <bits/stdc++.h>
using namespace std;
const int N=1e4+10;
const int M=2e5+10;
int e[M],ne[M],h[N],idx;
int n,m,d[N],ans;
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int dfs(int u)
{
    int res=0;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(j>u)//防止重复来回搜索，必须要确定一个大小关系
        {
            res+=(d[u]-1)*(d[j]-1);
        }
    }
    return res;
}
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    memset(h,-1,sizeof h);
    cin>>n>>m;
    int a,b;
    for(int i=0;i<m;i++)
    {
        cin>>a>>b;
        d[a]++,d[b]++;
        add(a,b),add(b,a);
    }
    for(int i=1;i<=n;i++)
    {
        ans+=dfs(i);
    }
    ans=ans*2;
    cout<<ans<<endl;
    return 0;
}

2.特殊的正方形(模拟)

可以记录一下该点是第几层，判断第几层的方法就是选取这个点距离上下左右水平距离，注意因为此时坐标是(1,1)开始，所以此点行列都对，但是补行和补列都得+1

比如2*2的矩阵，第（1，2）这个点，本质上从右往左数是第一圈，并不是第0圈，所以需要+1。

题目链接：特殊的正方形 - Problem - Daimayuan Online Judge

#include <bits/stdc++.h>
using namespace std;
const int N=101;
int n;
char p[N][N];
int main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            int a=min(i,n-i+1);
            int b=min(j,n-j+1);
            int res=min(a,b);
            if(res%2==1) p[i][j]='+';
            else p[i][j]='.';
        }
    
    for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
                cout<<p[i][j];
            if(i!=n)cout<<endl;
        }
    return 0;
}

3.走楼梯2(DP)

题目链接：走楼梯2 - Problem - Daimayuan Online Judge

开LL!!!

动态规划，思路是斐波那契数列，只是多加了限定条件，不能连续走3步

f[i][j]可能是由前一级台阶走过来的，也可能由前两级台阶走过来的

从前一级台阶走过来: f[i][j]=f[i-1][0]+f[i-1][1]+f[i-1][2]，前一级台阶可能已经连续走了0或1或2次两级台阶

从前两级台阶走过来: f[i][j]=f[i-2][0]+f[i-2][1]，前两级台阶可能已经连续走了0或1次两级台阶

接下来初始化:

f[0][0]=1：第0级台阶，已经走了0次两级台阶，为一种方案

#include <bits/stdc++.h>
using namespace std;
const int N=55;
typedef long long LL; 
LL f[N][N];//f[i][j]表示此时走到了第i台阶，已经连续走了j次跨2阶，由此可见，j=0,1,2; 
int n;
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    cin>>n;
    f[0][0]=1;
    for(int i=1;i<=n;i++)
    {
        f[i][0]=f[i-1][0]+f[i-1][1]+f[i-1][2];//状态转移跨一步的 
        if(i<2)continue;
        else//跨两步的 
        {
            f[i][1]=f[i-2][0]; 
            f[i][2]=f[i-2][1];
        }
    }
    cout<<f[n][0]+f[n][1]+f[n][2];
    return 0;
}

补：摆了好长时间。。。还好重新回正轨了qwq，继续努力！

 

 

 

2. 2023/3/16：

1.走路

题目链接：走路 - Problem - Daimayuan Online Judge

本质上其实是一个动态规划，就看转移方程怎么写

考虑动态规划，状态方程的含义：考虑前i次，能走到第j个地方
假如当前选择走a步，f[i][j]->f[i+1]j+a],f[i][j]能走到的地方f[i+1][j]都能
走到.(g+a≤m)
走b步同理.

#include <bits/stdc++.h>
#define io ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)

using namespace std;

const int N=110;
const int M=1e5+10;
bool f[N][M];
void solve()
{
    int n,m;
    cin>>n>>m;
    f[0][0]=true;
    for(int i=0;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        for(int j=0;j<=m;j++)
        {
            if(a+j<=m)f[i+1][j+a]|=f[i][j];
            if(b+j<=m)f[i+1][j+b]|=f[i][j];
        }
    }
    for(int i=0;i<=m;i++)
        cout<<f[n][i];
}
signed main()
{
    io;
    solve();
    return 0;
}

2.简单分数统计

题目链接：简单分数统计 - Problem - Daimayuan Online Judge

这个题没什么好说的，就是纯粹模拟这个考试对照分数的进程即可

#include <bits/stdc++.h>
#define io ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
const int N=210;
string id[N],ques[N];
string cp_id[N],cp_ques[N],res[N];
int score[N],f_ans[N];
int n,m,k;
int main()
{
    io;
    cin>>n>>m>>k;
    for(int i=0;i<n;i++)
        cin>>id[i];
    for(int i=0;i<m;i++)
        cin>>ques[i]>>score[i];
    for(int i=0;i<k;i++)
    {
        cin>>cp_id[i]>>cp_ques[i]>>res[i]; 
        for(int j=0;j<n;j++)//枚举第j个人 
        {
            if(cp_id[i]==id[j])
            {
                for(int q=0;q<m;q++) 
                {
                    if(res[i]=="AC"&&ques[q]==cp_ques[i]) f_ans[j]+=score[q];
                 }
            }
        }
    }
    for(int i=0;i<n;i++)
        cout<<id[i]<<" "<<f_ans[i]<<endl;
        
        
    
    return 0;
}

 

3. 2023/3/17：

1.Alice的德州扑克

题目链接：Alice的德州扑克 - Problem - Daimayuan Online Judge

暴力枚举，但是注意数据是递增的，所以不用自定义类型排序，如果不是递增的，那排序后打表的效率会大大增加

#include <bits/stdc++.h>
using namespace std;
//暴力打表，却依旧蕴含排序后的优化思想，所以只用打部分的表即可 
struct node{
    int a;//点数 
    int b;//花色 
}q[10];
inline void solve()
{
    for(int i=1;i<=5;i++)
        cin>>q[i].a;
    for(int i=1;i<=5;i++)
        cin>>q[i].b;
    
    if(q[1].a+1==q[2].a && q[2].a+1==q[3].a && q[3].a+1==q[4].a && q[4].a+1==q[5].a)//顺子 
    {
        if(q[1].b==q[2].b && q[2].b==q[3].b && q[3].b==q[4].b && q[4].b==q[5].b)//五张花色相同 
        {
            if(q[5].a==14)cout<<"ROYAL FLUSH";
            else cout<<"STRAIGHT FLUSH";
        }
        else cout<<"STRAIGHT";
    }
    else if(q[1].a==q[2].a && q[2].a==q[3].a && q[3].a==q[4].a || q[2].a==q[3].a && q[3].a==q[4].a && q[4].a==q[5].a)//四张点数相同
    {
        cout<<"FOUR OF A KIND";
    } 
    else if(q[1].a==q[2].a && q[2].a==q[3].a && q[4].a==q[5].a || q[1].a==q[2].a && q[3].a==q[4].a && q[4].a==q[5].a)//三张点数相同，另外两张也相同
        cout<<"FULL HOUSE" ;
    else if(q[1].b==q[2].b && q[2].b==q[3].b && q[3].b==q[4].b && q[4].b==q[5].b)
        cout<<"FLUSH";
    else cout<<"FOLD";
} 
signed main()
{
    solve();
    return 0;
} 

2.订单编号

题目链接：订单编号 - Problem - Daimayuan Online Judge

两种做法，想不到，太笨了qwq

1.利用set数组维护每次插入数据后，只有两种情况，要么这个数据在所维护未被利用的区间的中间，要么这个数据在已知大于这个数字最小的右端点区间的左边界左边，依据右端点排序，观察数据大概率是二分，思路，学到了用set来维护区间

2.利用并查集和unordered_map哈希表来巧妙处理父节点的父节点的父节点的。。。直到祖宗节点，最后把这个祖宗节点不断再+1

法一：

//法一：用set二元组来维护还没被处理过的区间 
#include <bits/stdc++.h>
#define io ios::sync_with_stdio(false),cin.tie(0),cout.tie(0) 
using namespace std;
const int N=5e5+10;
int n;
int a[N];
set<pair<int,int> > st;
inline void insert(int l,int r)
{
    if(l>r)return;
    st.insert({r,l});
}
void solve()
{
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    st.insert({2e9,1});//从右端点开始排序
    for(int i=0;i<n;i++)
    {
        auto it=st.upper_bound({a[i],0});
        int l=it->second,r=it->first;
        if(a[i]>l)
        {
            cout<<a[i]<<' ';
            st.erase(it);
            insert(l,a[i]-1);
            insert(a[i]+1,r);
        }
        else
        {
            cout<<l<<' ';
            st.erase(it);
            insert(l+1,r);
        }
    } 
    
}
signed main()
{
    io;
    solve();
    return 0;
}

法二：

#include <bits/stdc++.h>
using namespace std;
unordered_map<int,int> m;

inline int find(int x)
{
    if(!m[x])return x;
    return m[x]=find(m[x]);
}
inline void solve()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int x;
        cin>>x;
        int t=find(x);
        cout<<t<<' ';
        m[t]=t+1;
    }    
}
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

 

4. 2023/3/18：

1.饿饿 饭饭

题目链接：饿饿 饭饭 - Problem - Daimayuan Online Judge

首先观察题目的数据，5e5，最大nlogn，所以考虑二分出最后终止之前的完整轮数，不完整的最后一轮模拟，用deque双端队列一个一个模拟即可

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+10;
int n,k;
int a[N];
bool check(int x)
{
    int sum=0;
    for(int i=1;i<=n;i++)
        sum+=min(a[i],x);
    return sum<=k; 
}
inline void solve()
{
    cin>>n>>k;
    int sum=0;
    for(int i=1;i<=n;i++)
        cin>>a[i],sum+=a[i];
    if(sum<k){cout<<"-1"<<endl;return;}
    if(sum==k){cout<<endl;return;}
    //否则实际饭一定还有剩余
    //二分最大的完整轮数
    int l=0,r=1e9;
    while(l<r)
    {
        int mid=l + r + 1 >> 1;
        if(check(mid))l=mid;
        else r=mid-1;
    }//l是最大轮数
    int res=0;
    for(int i=1;i<=n;i++)
        res+=min(a[i],l),a[i]-=min(l,a[i]);
    k-=res;//手动模拟最后不完整的一轮
    deque<int> q;//双端队列
    for(int i=1;i<=n;i++)
        if(a[i])q.push_back(i); 
    while(k--)
    {
        a[q.front()]--;
        if(a[q.front()]>0)q.push_back(q.front());
        q.pop_front();
    }
    for(int x:q)cout<<x<<' ';
    cout<<endl;
        
}
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

2.任务分配

题目链接：任务分配 - Problem - Daimayuan Online Judge

emm，dp，但是至于为什么不用贪心，还需要再悟悟，目前个人理解就是贪心不能保证全局最优解不包含在局部最优解的情况，所以用更加全面的dp来写，看似不一定是最大值或者最小值，但一定是当前子问题的最优解，

 

 注意：每次收益最大的时候即为这个任务做完的时刻（创建一个结构体），所以用右端点排序。

//dp 每次收益最大一定是完成某个任务的结束点 
#include <bits/stdc++.h>
using namespace std;
const int N=1e3+10; 
int f[N];//f[i]表示i时刻结束的最大收益 
int n; 
struct node{
    int s;//start开始时间 
    int e;//end结束时间 
    int w;//权重 
}a[N];
bool cmp(node a,node b)
{
    if(a.e=b.e)return a.s<b.s;
    else return a.e<b.e;
}//按照结束时间排序 
inline void solve()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i].s>>a[i].e>>a[i].w;
    sort(a+1,a+1+n,cmp);
    for(int i=1;i<=n;i++)
        for(int j=0;j<=i;j++)
            if(a[j].e<=a[i].s)
                f[a[i].e]=max(f[a[i].e],f[a[j].e]+a[i].w);
    int ans=0;
    for(int i=1;i<=n;i++)ans=max(ans,f[a[i].e]);
    cout<<ans<<endl; 
}
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

3.路径计数

题目链接：路径计数 - Problem - Daimayuan Online Judge

这个就是最简单的dp，但是捏麻麻的debug了一个小时，原因是：所有前一步都会影响下一步，所以初始化第一行第一列的时候，当前一个点不能走了（0），这一行/这一列之后的点都是0，而不能直接单个判断每个点是否是0来决定其f[i][j]是否是可走的。牵一发而动全身！！！！

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=1100;
const int MOD=1e9+7;
int f[N][N],a[N][N];
int n;//dp f表示方案数，a表示地图 
inline void solve()
{
    cin>>n;
    bool flag=1;//一定要有一个flag，因为一旦第一行或者第一列的某个点是0，则后面的点都是0，即前面都没办法到，必经之路被挡住了
    //！！！！！！！！！！！！大坑，捏妈妈，我是傻逼，看了一个小时才看出来 
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            cin>>a[i][j];
            
    for(int i=0;i<n;i++){
    
        if(a[0][i]==0)flag=false;
        if(flag) f[0][i]=1;
        else f[0][i]=0;
}
    flag=true;
    for(int i=0;i<n;i++){
    
        if(a[i][0]==0)flag=false;
        if(flag) f[i][0]=1;
        else f[i][0]=0;
}
    for(int i=1;i<n;i++)
        for(int j=1;j<n;j++)
            if(!a[i][j])f[i][j]=0;
            else f[i][j]=(f[i-1][j]+f[i][j-1]) % MOD;
            
    cout<<f[n-1][n-1]<<endl;
        
            
}
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

4.最大和上升子序列

题目链接：最大和上升子序列 - Problem - Daimayuan Online Judge

这是一道经典的dp问题

#include <bits/stdc++.h>
using namespace std;
const int N=1010;
int n,ans;
int a[N],f[N];//dp
inline void solve()
{
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    
    for(int i=0;i<n;i++)
    {
        f[i]=a[i];//初始化
        for(int j=0;j<i;j++)
        {
            if(a[j]<a[i])f[i]=max(f[i],f[j]+a[i]);
        } 
    }
    
    for(int i=0;i<n;i++)
        ans=max(ans,f[i]);
    
    cout<<ans<<endl;
}
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
} 

5.加一

题目链接：加一 - Problem - Daimayuan Online Judge

思路很新，也是用dp，f[i] [j]的意思是：原本是j的数位经过i次操作后变成了f[i] [j]位。

注意，这个题卡了读写数据，必须用scanf和printf。ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)都不可以！事实证明还是前者更快一点

#include <bits/stdc++.h>
using namespace std;
const int MOD=1e9+7;
typedef long long LL;
int n;
const int N=2e5+10;
LL f[N+50][20];//f[i][j]表示当前数位是j的数字操作i次后，整个数字的位数 
inline void solve()
{
    scanf("%d",&n);
    for(int i=0;i<=9;i++)f[0][i]=1;
    for(int i=1;i<=N;i++)//预处理,类似于前缀和 
    {
        for(int j=1;j<=9;j++)f[i][j-1]=f[i-1][j];
        f[i][9]=(f[i-1][0]+f[i-1][1])%MOD;
    }
    while(n--)
    {
        char str[20];
        int m=0,res=0;
        scanf("%s %d",&str,&m);
        int len=strlen(str); 
        for(int i=0;i<len;i++)
        {
            res+=f[m][str[i]-'0'];
            res%=MOD; 
        }
        printf("%d\n",res);
    }
} 
signed main()
{
    solve();
    return 0;
}