2018湖南省多校第一场解题报告(CSU OJ)

最新推荐文章于 2020-12-12 11:21:59 发布
最新推荐文章于 2020-12-12 11:21:59 发布
阅读量270 收藏
点赞数
分类专栏： ACM/ICPC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36398723/article/details/79808685
版权

A Artwork ：并查集倒着推

//题目原型，删点之后图上还剩下多少个联通块
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int MAXM=11000;
const int MAXN=1100;
bool del[MAXN][MAXN];
int fa[MAXN*MAXN];
int find(int x)
{
    return fa[x]==-1?x:fa[x]=find(fa[x]);
}
bool unite(int a,int b)
{
    int t1=find(a),t2=find(b);
    if(t1==t2) return false;
    fa[t1]=t2;
    return true;
}
struct point_t
{
    int x,y;
    point_t() {}
    point_t(int _x,int _y):x(_x),y(_y) {}
};
struct line_t
{
    point_t a,b;
    line_t() {}
    line_t(point_t _a,point_t _b):a(_a),b(_b) {}
}question[MAXM];
vector<int> vec[MAXM];
const int L[]={1,0,-1,0};
const int R[]={0,1,0,-1};
int get_hashs(int x,int y,int n)
{
    x--,y--;
    return x*n+y;
}
int answer[MAXM];
int change(int x,int y,int n,int m)
{
    int ret=1;
    for(int i=0;i<4;i++)
    {
        int tempx=x+L[i],tempy=y+R[i];
        if(tempx<1||tempx>n||tempy<1||tempy>m||del[tempx][tempy]) continue;
        if(unite(get_hashs(x,y,m),get_hashs(tempx,tempy,m))) ret--;
    }
    return ret;
}
int main()
{
//    freopen("in.txt","r",stdin);
    int n,m,q;
    while(scanf("%d%d%d",&n,&m,&q)!=EOF)
    {
        for(int i=1;i<=1;i++)
            vec[i].clear();
        memset(fa,-1,sizeof(fa));
        memset(del,false,sizeof(del));
        for(int i=1;i<=q;i++)
        {
            int x1,y1,x2,y2;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            question[i]=line_t(point_t(x1,y1),point_t(x2,y2));
        }
        //然后离线开始慢慢加边
        for(int i=1;i<=q;i++)
        {
            if(question[i].a.x==question[i].b.x)
            {
                int x=question[i].a.x;
                for(int j=question[i].a.y;j<=question[i].b.y;j++)
                {
                    if(del[x][j]) continue;
                    del[x][j]=true;
                    vec[i].push_back(j);
                }
            }
            else
            {
                int y=question[i].a.y;
                for(int j=question[i].a.x;j<=question[i].b.x;j++)
                {
                    if(del[j][y]) continue;
                    del[j][y]=true;
                    vec[i].push_back(j);
                }
            }
        }
//        for(int i=1;i<=q;i++)
//        {
//            printf("question :%d\n",i);
//            for(int j=0;j<vec[i].size();j++)
//                printf("%d ",vec[i][j]);
//            printf("\n")
//        }
        for(int i=1;i<=n;i++)
           for(int j=1;j<=m;j++)
            {
                if(del[i][j]) continue;
//                printf("No DEl :%d %d\n",i,j);
                for(int k=0;k<4;k++)
                {
                    int x=i+L[k],y=j+R[k];
                    if(x<1||x>n||y<1||y>m) continue;
                    if(del[x][y]) continue;
                    int new1=get_hashs(i,j,m);
                    int new2=get_hashs(x,y,m);
                    unite(new1,new2);
//                    printf("new1 :%d new2 :%d\n",new1,new2);
                }
            }
        int total=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
            {
                if(del[i][j]) continue;
                int hashed=get_hashs(i,j,m);
                if(fa[hashed]==-1) total++;
//                printf("hashed :(%d,%d) %d \n",i,j,fa[hashed]);
            }
        answer[q]=total;
        for(int i=q;i>=2;i--)
        {
            //然后加上删去的方块，看有多少个
            line_t line=question[i];
//            printf("(%d,%d)->(%d,%d)\n",line.a.x,line.a.y,line.b.x,line.b.y);
            int blocks=answer[i];
            if(line.a.x==line.b.x)
            {
                int x=line.a.x;
                for(int j=0;j<vec[i].size();j++)
                {
                    //如果这个方块已经被删去了，那么加上他
                    int mmp=vec[i][j];
                    if(del[x][mmp])
                    {
                        del[x][mmp]=false;
                        blocks+=change(x,mmp,n,m);
                    }
                }
                answer[i-1]=blocks;
            }
            else
            {
                int y=line.a.y;
                for(int j=0;j<vec[i].size();j++)
                {
                    int mmp=vec[i][j];
                    if(del[mmp][y])
                    {
                        del[mmp][y]=false;
                        int temp=change(mmp,y,n,m);
                        blocks+=temp;
                    }
                }
                answer[i-1]=blocks;
            }
        }
        for(int i=1;i<=q;i++)
            printf("%d\n",answer[i]);
    }
    return 0;
}

B Bless You Autocorrect! : 字典树+bfs（其实没必要用spfa求得最短路，因为每条边的距离都是1，所以bfs可以直接求得距离，qaq）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int SIZE=1111111;
struct node_t
{
    int son[28];
    int idx;
}node[SIZE];
//其中26记录的是fa节点，27记录的是tab节点
int toUsed;
char word[SIZE];
void init()
{
    toUsed=1;
    memset(node,-1,sizeof(node_t));
}
inline int _newnode()
{
    memset(node+toUsed,-1,sizeof(node_t));
    return toUsed++;
}
void insert(const char *str,int idx)
{
    int root=0;
    for(int i=0;str[i];i++)
    {
        int sn=str[i]-'a';
        if(node[root].son[sn]==-1) node[root].son[sn]=_newnode();
        node[node[root].son[sn]].son[26]=root;
        root=node[root].son[sn];
    }
    int cur=0;
    for(int i=0;str[i];i++)
    {
        int sn=str[i]-'a';
        cur=node[cur].son[sn];
        if(node[cur].son[27]==-1) node[cur].son[27]=toUsed-1;
    }
    node[root].idx=idx;
//    printf("Word :%s table[%d] :%d\n",word,idx,table[idx]);
}
//搜索每一个节点tab键后会跳转到哪里
//对于每个要查询的字符串，我们首先找到其能在字典树上匹配到的最大长度，其次然后做bfs求得最短距离
//记录0点到每一个点之间的最短距离
int dist[SIZE];
bool vis[SIZE];
void spfa(int s)
{
    memset(vis,false,sizeof(vis));
    memset(dist,0x3f,sizeof(dist));
    vis[s]=true;dist[s]=0;
    node[s].son[27]=-1;
    queue<int> que;
    while(!que.empty()) que.pop();
    que.push(s);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        vis[u]=true;
        for(int i=0;i<28;i++)
        {
            if(node[u].son[i]==-1) continue;
            int v=node[u].son[i];
            if(dist[v]>dist[u]+1)
            {
                dist[v]=dist[u]+1;
//                if(v==7) printf("from %d -> %d :%d\n",u,v,dist[v]);
                if(!vis[v])
                {
                    vis[v]=true;
                    que.push(v);
                }
            }
        }
    }
}
int query(const char *str)
{
    //i记录能匹配到的最大长度
    int i,final_node=0;
    for(i=0;str[i];i++)
    {
        int sn=str[i]-'a';
        if(node[final_node].son[sn]==-1) break;
        final_node=node[final_node].son[sn];
    }
    //然后bfs求得从0点到final点的最短距离
    int lens=strlen(str);
//    printf("final_node :%d   %d + %d\n",final_node,dist[final_node],lens-i);
    return dist[final_node]+lens-i;
}
int main()
{
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i=0;i<n;i++)
        {
            scanf("%s",word);
            insert(word,i);
        }
        spfa(0);
        for(int i=0;i<m;i++)
        {
            scanf("%s",word);
            int ans=query(word);
            printf("%d\n",ans);
        }
        printf("\n");
    }
    return 0;
}

C Card Hand Sorting ：暴力枚举 + 最长公共子序列

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
//枚举（(2^4)*4!）种排列组合，求得最少要移动多少次
const int MAXN=60;
struct pock_t
{
    int ranks;
    char suits;
    pock_t() {}
    pock_t(int _ranks,char _suits):ranks(_ranks),suits(_suits) {}
}pock[MAXN],temp[MAXN];
int trans(char x)
{
    if(x>='2'&&x<='9') return x-'0';
    else if(x=='T') return 10;
    else if(x=='J') return 11;
    else if(x=='Q') return 12;
    else if(x=='K') return 13;
    else return 14;
}
//然后爆搜加上枚举生成每种排列组合
const char suits[]={'s','h','d','c'};
char change[4];
int up_down[4];
bool vis[4];
int n,ans;
int find(char suit)
{
    for(int i=0;i<4;i++)
        if(change[i]==suit) return i;
    return -1;
}
bool cmp(const pock_t& a,const pock_t& b)
{
    //首先如果花色相同
    int fucka=find(a.suits),fuckb=find(b.suits);
    if(a.suits==b.suits)
    {
        if(up_down[fucka]==1) return a.ranks<b.ranks;
        else return a.ranks>b.ranks;
    }
    else return fucka<fuckb;
}
//记录最长上升子序列
int dp[MAXN][MAXN];
void solve()
{
    memcpy(temp,pock,sizeof(pock));
    sort(temp+1,temp+n+1,cmp);
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(pock[i].ranks==temp[j].ranks&&pock[i].suits==temp[j].suits)
                dp[i][j]=dp[i-1][j-1]+1;
            else dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
    ans=min(ans,n-dp[n][n]);
}
void dfs(int depth)
{
    if(depth==4) solve();
    else
    {
        for(int i=0;i<4;i++)
        {
            if(vis[i]) continue;
            vis[i]=true;
            up_down[depth]=1;
            change[depth]=suits[i];
            dfs(depth+1);
            up_down[depth]=-1;
            change[depth]=suits[i];
            dfs(depth+1);
            vis[i]=false;
        }
    }
}
int main()
{
//    freopen("in.txt","r",stdin);
    while(scanf("%d",&n)!=EOF)
    {
        char tra,suit;
        for(int i=1;i<=n;i++)
        {
            cin>>tra>>suit;
            pock[i]=pock_t(trans(tra),suit);
        }
        ans=0x3f3f3f3f;
        memset(vis,false,sizeof(vis));
        dfs(0);
        cout<<ans<<endl;
    }
    return 0;
}

D Daydreaming Stockbroker （dp）

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
typedef long long LL;
const int MAXN=400;
LL dp[MAXN];
LL stock[MAXN];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
            cin>>stock[i];
        dp[1]=100;
        //其实也可以选择一直不买，反正结果的时候比一比就知道了
        for(int i=2;i<=n;i++)
        {
//            puts("MMP");
            LL no_buy=0;
            for(int j=1;j<i;j++)
            {
                //其实也可以选择当天不买
                no_buy=max(no_buy,dp[j]);
                LL win=(stock[i]-stock[j]);
                if(win<0) continue;
                LL could_buy=dp[j]/stock[j];
                LL rem=dp[j]%stock[j];
                if(could_buy>100000)
                {
                    rem+=(could_buy-100000)*stock[j];
                    could_buy=100000;
                }
                dp[i]=max(dp[i],rem+stock[i]*(could_buy));
//                cout<<dp[i]<<endl;
            }
            dp[i]=max(no_buy,dp[i]);
//            printf("dp[%d] :%d\n",i,dp[i]);
        }
        cout<<dp[n]<<endl;
    }
    return 0;
}

神里凌华的舔狗
关注
专栏目录
CSU OJ 1120 病毒（湖南省第八届大学生计算机程序设计竞赛）
Just do it !
05-21 1943
 1120: 病毒 Time Limit: 3 Sec  Memory Limit: 128 MB Submit: 146  Solved: 53 [Submit][Status][Web Board] Description 你有一个日志文件，里面记录着各种系统事件的详细信息。自然的，事件的时间戳按照严格递增顺序排列（不会有两个事件在完全相同的时刻发生）。 遗憾
湖南省第十届"蓝狐网络杯"大学生计算机程序设计竞赛,2018湖南省第14届大学生计算机程序设计竞赛 C: 时间旅行...
weixin_42517607的博客
06-24 633
Description 假设 Bobo 位于时间轴(数轴)上t0点,他要使用时间机器回到区间(0, h]中. 当 Bobo 位于时间轴上t点,同时时间机器有c单位燃料时,他可以选择一个满足⌈xh⌉⋅h≤c⌈xh⌉⋅h≤c的非负整数x, 那么时间机器会在[0, x]中随机整数y,使 Bobo 回到(t − y)点,同时消耗y单位燃料. (其中⌈ ⋅ ⌉表示上取整...
CSU OJ 三家人（湖南省第八届大学生计算机程序设计竞赛）
旧时相识的专栏
09-03 1091
题目链接：http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1111     这是道简单的数学题。 #include int main() { int t,z,d;; float x,y,k,s; scanf("%d",&t); int i; while (t--) { sc
CSU OJ：1241 数字序列（并查集+思维)
zugofn的博客
04-12 982
1241: 数字序列 Submit Page     Summary    Time Limit: 1 Sec     Memory Limit: 128 Mb     Submitted: 200     Solved: 31     Description Staginner在纸上依次写下了n个数，分别记为a1,a2,...,an，然后他给CSGrandeu
CSU OJ终于好了
weixin_30241919的博客
08-11 185
心情都愉悦了 转载于:https://www.cnblogs.com/wejex/p/3250985.html
【数学】CSU 1810 Reverse (2016湖南省第十二届大学生计算机程序设计竞赛)
Coolxxx的博客
09-05 621
题目链接： 　　http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1810 题目大意： 　　一个长度为N的十进制数，R(i,j)表示将第i位到第j位翻转过来后的数字，求mod 109+7 题目思路： 　　【数学】 　　这题换一种思路，看每个数字能够对答案的贡献情况。(可以手推01，10，001，010，100.
CSU OJ 1111 三家人 （湖南省第八届大学生计算机程序设计竞赛）
Just do it !
05-21 2074
 1111: 三家人 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 356  Solved: 142 [Submit][Status][Web Board] Description 有三户人家共拥有一座花园，每户人家的太太均需帮忙整理花园。A 太太工作了5 天，B 太太则工作了4 天，才将花园整理完毕。C 太太因为正
【最短路】【数学】CSU 1806 Toll (2016湖南省第十二届大学生计算机程序设计竞赛)
Coolxxx的博客
09-07 414
题目链接： 　　http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1806 题目大意： 　　N个点M条有向边，给一个时间T(2≤n≤10,1≤m≤n(n-1),1≤T≤104)，每条边的花费是关于t的一次函数Ci*t+Di，而你能选择出发时间t(0 题目思路： 　　【最短路】【数学】 　　这题首先有个积分符号被
DS_CSU8RP1185D_V1.2_cn_csu8rp1185_CSU8RP1185D芯片用户手册_CSU8RP1185D_
10-03
1. **8位CPU内核**：CSU8RP1185D内置了高效的8位CPU，能处理各种计算任务，适合资源有限但对处理能力有一定要求的场景。 2. **36引脚封装**：采用小型化封装，节省PCB空间，便于设计紧凑型电子产品。 3. **OTP ROM...
csu oj 1010 Water Drinking（BFS）
程序员的冷浪漫
10-02 1380
#include #include #include #include #include using namespace std; #define M 100005 #define INF 1 #define CLS(x,v)  memset(x,v,sizeof(x)) int right[M]; int head[M]; void link(int x,int
1989CSUOJ
binarycopycode
09-08 395
很久以前做这题spfa是能A了，然而swb大佬无情卡掉spfa。 昨天做这题因为这题不是吧所有点都能走到，所以要加个特盘不然会死循环，我的dij模板以前是有漏洞的。 #include #include #include #define maxn 10010 #define maxl 50010 #define inf 2000000001 using namespace std; int
CSU OJ 代码搜集（1000-1300）
nameofcsdn的博客
12-12 2539
1004: Xi and Bo #include <stdio.h> #define N 105 int fa[N]; int a[N]; void InitSet(int n){ for(int i=1; i<=n; i++) fa[i] = i ; } int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]) ; } bool Merge(int u ,in
CSUOJ 1284 Cutting Cake（递推）
nudt_oys的博客
07-13 814
1284: Cutting Cake Description 一个蛋糕切N刀，最多能得到多少块？切的过程中不能改变任意一块蛋糕的位置。 Input 输入数据的第一行包含一个整数T (1 ，表示接下来一共有T组测试数据。 每组测试数据占一行，包含一个整数N (1 ，含义同上。 Output 用一行输出一个整数，
CSUOJ题目整理
Aczy156的博客
05-19 2079
Assemble Assemble Time Limit: 1 Sec Memory Limit: 128 Mb Submitted: 42 Solved: 18 Description Xrdog准备组装一台属于他自己的电脑。 具体来说是这样子的，组装这台电脑需要n个部件(显卡,CPU,硬盘…),每种部件均有k个品牌的产品，不同的产品会有一个性能值来衡量它的性能。Xrdo...
csuoj--1307
荒野孤鹰
08-14 1009
dijkstra算法的一种变形吧 题目要求的是最长路的最小值,所以用二分
CSUOJ-----锋芒不露
还木人的博客
06-14 463
Description小闪最近迷上了二刀流——不过他耍的其实是剑——新买了一个宝库用来专门存放自己收集的双剑。一对剑有两把，分只能左手用的和只能右手用的，各自有一个攻击力数值。虽然一对剑在小闪刚拿到时是一对，不过其实可以认为它们是独立的两把剑。一对剑的攻击力是左右两把剑的攻击力之和，小闪可以自由地搭配左右剑来练习二刀流。每次小闪得到一对新的双剑，他都可以去更新一次自己的双剑宝库，重新给每把剑配对。...
CSUOJ 1900 锋芒不露
weixin_34273481的博客
05-13 140
Description小闪最近迷上了二刀流——不过他耍的其实是剑——新买了一个宝库用来专门存放自己收集的双剑。一对剑有两把，分只能左手用的和只能右手用的，各自有一个攻击力数值。虽然一对剑在小闪刚拿到时是一对，不过其实可以认为它们是独立的两把剑。一对剑的攻击力是左右两把剑的攻击力之和，小闪可以自由地搭配左右剑来练习二刀流。每次小闪得到一对新的双剑，他都可以去更新一次...
csu oj 1539 数学公式
hiding_nya的博客
05-14 407
//csu oj 1539 space golf #include #include #include #include #include #define maxn 20000 #define inf 0x3f3f3f using namespace std; struct node { double x,y; }p[maxn]; double Min(double a,double b)
ACM编程竞赛在线判题系统：全球知名OJ网站集合
本文将介绍一系列国内外知名的在线判题系统（Online Judge，简称OJ），这些平台主要用于ACM（国际大学生程序设计竞赛）训练及编程练习。这些网站提供了丰富的编程题目，涵盖了各种算法和问题解决技巧，对于提升编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值