2021年度训练联盟热身训练赛第四场补题

最新推荐文章于 2021-08-20 22:36:04 发布

shall_zhao

最新推荐文章于 2021-08-20 22:36:04 发布

阅读量619

点赞数

分类专栏：学习经验分享文章标签：算法

本文链接：https://blog.csdn.net/shall_zhao/article/details/115308411

版权

学习经验分享专栏收录该内容

39 篇文章 3 订阅

订阅专栏

总的来说，这场比赛对于我来说，实在是有点难。补题的时候，不能全补，所以那些实在不会的先空起来啦，链接放在下方，等有能力并且想起来的时候，回来再补吧。

链接如下：link——点我看比赛

B:Connect3

【题目描述】

在这里插入图片描述

【输入描述】

在这里插入图片描述

【输出描述】

在这里插入图片描述

【示例1】

输入
复制
2
2 3
输出
复制
516

【示例2】

输入
复制
3
4 4
输出
复制
177

【解题思路】

模拟题，直接模拟两个人轮流操作，形成的最终局面，最后检测局面是否只有(a,b)可以形成三个在一起的局面，可以使用三进制来表示最终局面，以避免重复计算。

【代码展示】

代码我还真的有点理解不了，拿的人家主办方的代码，把代码存在网盘里
先放着吧

#include<bits/stdc++.h>
using namespace std;
pair<int,int> a,b;
int g[5][5],cnt[4],ans;
bool vis[43046721+10];//3**16+10,用于去重
int same(pair<int,int> x,pair<int,int> y,pair<int,int> z,int &f)
{
    if(g[x.first][x.second]>0 && g[x.first][x.second]==g[y.first][y.second] && g[x.first][x.second]==g[z.first][z.second])
    {
        if(x==b || y==b || z==b) {f=1;return 1;}
        return 2;
    }
    return 0;
}
//返回值为1表示3个相同且包含(a,b)
//返回值为2表示3个相同且不包含(a,b)
//返回值为0表示3个不完全相同
bool check()
{
    int flag=0,k=0;
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
            k=k*3+g[i][j];
    if(vis[k]) return 0;
    vis[k]=1;
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
        {
            if(i+2<4)
            {
                int k=same({i,j},{i+1,j},{i+2,j},flag);
                if(k>1) return 0;
            }
            if(j+2<4)
            {
                int k=same({i,j},{i,j+1},{i,j+2},flag);
                if(k>1) return 0;
            }
            if(i+2<4 && j+2<4)
            {
                int k=same({i,j},{i+1,j+1},{i+2,j+2},flag);
                if(k>1) return 0;
            }
            if(i+2<4 && j-2>=0)
            {
                int k=same({i,j},{i+1,j-1},{i+2,j-2},flag);
                if(k>1) return 0;
            }
        }
    return flag;
}
void dfs(int p)
{
    if(cnt[b.second]==b.first+1)
    {
        if(p==0) ans+=check();
        return;
    }
    for(int i=0;i<4;i++)
        if((i!=b.second && cnt[i]<4) || (i==b.second && cnt[i]<=b.first))
        {
            g[cnt[i]][i]=p+1;
            cnt[i]++;
            dfs(1-p);
            cnt[i]--;
            g[cnt[i]][i]=0;
        }
}
int main()
{
    a.first=0;
    scanf("%d%d%d",&a.second,&b.first,&b.second);
    a.second--,b.first--,b.second--;
    g[a.first][a.second]=1;
    cnt[a.second]++;
    dfs(1);
    printf("%d\n",ans);
    return 0;
}

C:Game Map

【题目描述】

在这里插入图片描述

【输入描述】

在这里插入图片描述

【输出描述】

在这里插入图片描述

【示例1】

输入
复制
6 9
0 1
0 4
1 2
1 3
1 4
1 5
2 5
3 4
4 5
输出
复制
4

【示例2】

输入
复制
12 11
1 2
2 3
3 4
4 5
5 0
6 3
7 4
8 5
9 4
10 5
11 5
输出
复制
5

【思路解析】

记录每个节点的度数，节点按照度数从小到大排序
dp[u] = max(dp[u],dp[v]+1)其中u节点和v节点为邻居，并且d[u] > d[v]
dp数组的最大值即为答案。

【代码展示】

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stack>
#include <map>
#include<bits/stdc++.h>
#define ll long long
using namespace std;

int f[10000+5];
int flag;
vector<vector<int> > a;//相当于二维数组，用来存储这个图的每一条边

int dfs(int node)
{
    if(!f[node])
    {
        f[node] = 1;
    }
    for(auto it = a[node].begin();it != a[node].end();it++)
    {
        if(a[node].size() < a[*it].size())//如果node这个点的度小于他的相邻点的度
        {
            f[node] = max(f[node],dfs(*it)+1);//就要dfs的找寻这个点的最大度
        }
    }
    return f[node];
}

int main()
{

    int n,m;
    cin>>n>>m;
    a.resize(n);
    for(int i=0;i<m;i++)
    {
        int x,y;
        cin>>x>>y;
        a[x].push_back(y);//建边
        a[y].push_back(x);
    }
    int ans = 0;
    for(int i=0;i<n;i++)
    {
        ans = max(ans,dfs(i));
    }
    cout<<ans<<endl;
    return 0;
}

D:Happy Number

【题目描述】

在这里插入图片描述

【输入描述】

在这里插入图片描述

【输出描述】

在这里插入图片描述

【示例1】

输入
复制
19
输出
复制
HAPPY

【示例2】

输入
复制
5
输出
复制
UNHAPPY

【题意分析】

官方解答：模拟n是否会变成1，可以发现f[n]不会超过1000，开桶记录是否可以成环就可以判别。
个人理解：就是每一次要求这个数字的各位数字的平方和，每次都要更新这个数字为他的平方和，如果出现环，就说明不嗨皮，否则结果一定会变成1，就是happy，所以才使用=桶，这样就可以很方便的记录下，每一个出现的平方和的值

【代码展示】

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stack>
#include <map>
#include<bits/stdc++.h>
#define ll long long
using namespace std;

bool f[10005];
int main()
{
    ll n;
    cin>>n;
    while(n!=1)
    {
        int sum = 0;
        while(n)
        {
            sum += (n%10)*(n%10);
            n/=10;
        }
        if(f[sum])//如果出现过
        {
            puts("UNHAPPY");
            return 0;
        }
        else
        {
            f[sum] = 1;
            n = sum;//更新n的值
        }
    }
    puts("HAPPY");
    return 0;
}

F:Philosopher‘s Walk

【题目描述】

在这里插入图片描述

【输入描述】

在这里插入图片描述

【输出描述】

在这里插入图片描述

【示例1】

输入
复制
4 10
输出
复制
3 4

【示例2】

输入
复制
8 19
输出
复制
2 6

【题意解析】

官方解析：不断的四分，根据m的大小判定答案所在的具体位置，租后根据旋转的坐标关系得到最后的答案。
我的解析：比赛的现场，我的第一直觉是递归，因为是每一个大的正方形都有四个比他小一点的正方形通过旋转的方式，拼接在一起的，于是，我就开始找他们的坐标关系，在验证了n=4的时候，他所对应的更小的正方形的关系，就开始按照递归的想法开始写代码了，但是，终于在最后一个小时的时候，把所有的错误都解决掉的时候，才发现每个正方形的右下角的那一块找不到规律了。看完人家的代码，还是有点难傻傻分不清楚，什么是递归，什么是DFS，希望以后能有点更深的理解，不过，我觉得我在赛场上的思路没有错，不过是自己的能力太差劲了，敲代码花了很长的时间，另一方面，最后一块的规律自己也没找出来，以后多加油

【代码展示】

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
int x,y;
//说白了就是分成四块，按照这四块的规律，进行dfs，但是这个规律实在是太难找了。
void dfs(int n,int m)
{
    if(n==1)
    {
        if(m==1) x = y =1;
        else if(m == 2) x=1,y = 2;
        else if(m==3)  x = y =2;
        else x=2,y=1;
        return ;
    }
    if(m<= n*n/4)
    {
        dfs(n/2,n*n/4-m+1);
        swap(x,y);
        y = n/2 +1 -y;
    }
    else if(m<=n*n/2)
    {
        dfs(n/2,m-n*n/4);
        y += n/2;
    }
    else if(m <= n*n/4*3)
    {
        dfs(n/2,m-n*n/2);
        x += n/2;
        y += n/2;
    }
    else{
        dfs(n/2,n*n-m+1);
        swap(x,y);
        x = n/2+1-x;
        x += n/2;
    }
}
int main()
{
    int n,m;
    cin>>n>>m;
    dfs(n,m);
    cout<<x<<" "<<y<<endl;
    return 0;
}