暑假训练9

最新推荐文章于 2025-07-20 10:56:12 发布

原创最新推荐文章于 2025-07-20 10:56:12 发布 · 105 阅读

CC 4.0 BY-SA版权

题意：有n种剑，每种有x个，现在几个人每人偷Y个（Y个同种剑），给你被透过之后的剑种类数量，问你原来有几种多少个。

思路：先把最大的数量找到，这就是x的值，然后用它减去每个剑的数量找出每个剑被偷了多少，各个找公约数，最后就找到了所有的公约数。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
ll int gcd(ll int a,ll int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);
}
int num[200005];
int main()
{
    int n;
    cin>>n;
    int maxx=-1;
    for(int i=0;i<n;i++)
        cin>>num[i];

    sort(num,num+n);
    maxx=num[n-1];
    int g;
    for(int i=0;i<n-1;i++)
        if(i==0)
            g=maxx-num[i];
        else
            g=gcd(now,maxx-num[i]);
    ll int ans=0;

    for(int i=0;i<n-1;i++)
        ans+=(maxx-num[i])/g;
    
        cout<<ans<<" "<<now<<endl;

    return 0;
}

题意：就是用两个矩形问能不能覆盖另一个矩形，能就YES，不能就NO

思路：感觉是个体力活，也找不到好的方法。
白布的四个点没有被完全遮住，直接YES
白布四个点被遮住，且四个点包含在同一块黑布中：NO
白布四个点被遮住，四个点分布在两块黑布中，且黑布没有交集：YES
白布四个点被遮住，四个点分布在两块黑布中，且黑布有交集：NO


#include <bits/stdc++.h>
const int N=1e6+10;
typedef long long ll;

using namespace std;

bool in(ll x1,ll y1,ll x2,ll y2,ll xx2,ll yy2) 
{
    return (x1 >= x2 && y1 >= y2 && x1<= xx2 && y1 <= yy2);
}

int main()
{
    ll x1,x2,x3,y1,y2,y3;
    ll xx1,xx2,xx3,yy1,yy2,yy3;
    while(cin>>x1>>y1>>xx1>>yy1){
    cin>>x2>>y2>>xx2>>yy2;
    cin>>x3>>y3>>xx3>>yy3;

    if((in(x1,y1,x2,y2,xx2,yy2) || in(x1,y1,x3,y3,xx3,yy3)) &&
       (in(xx1,y1,x2,y2,xx2,yy2) || in(xx1,y1,x3,y3,xx3,yy3)) &&
       (in(x1,yy1,x2,y2,xx2,yy2) || in(x1,yy1,x3,y3,xx3,yy3)) &&
       (in(xx1,yy1,x2,y2,xx2,yy2) || in(xx1,yy1,x3,y3,xx3,yy3)))
    {

        if(in(x3,y3,x2,y2,xx2,yy2) ||
           in(xx3,y3,x2,y2,xx2,yy2) ||
           in(x3,yy3,x2,y2,xx2,yy2) ||
           in(xx3,yy3,x2,y2,xx2,yy2) ||
           in(x2,y2,x3,y3,xx3,yy3) ||
           in(xx2,y2,x3,y3,xx3,yy3) ||
           in(x2,yy2,x3,y3,xx3,yy3) ||
           in(xx2,yy2,x3,y3,xx3,yy3) )
            cout<<"NO"<<endl;
        else
        {
            if((in(x1,y1,x2,y2,xx2,yy2) && in(xx1,y1,x2,y2,xx2,yy2) && in(x1,yy1,x2,y2,xx2,yy2) && in(xx1,yy1,x2,y2,xx2,yy2)) ||
               (in(x1,y1,x3,y3,xx3,yy3) && in(xx1,y1,x3,y3,xx3,yy3) && in(x1,yy1,x3,y3,xx3,yy3) && in(xx1,yy1,x3,y3,xx3,yy3)) )
                cout<<"NO"<<endl;
            else
                cout<<"YES"<<endl;
        }
    }
    else
        cout<<"YES"<<endl;
    }
    return 0;
}

题意：就是每次可以将n个数中某两个数加起来放到原位置，问你最后能不能得到2048，能YES 不能NO

思路：其实没想得那么复杂，根本不应该去考虑加法运算的这个过程，而应该把每个2048的约数都加起来，看能不能得到这个2048，不过不能盲目一个个加，不然很容易遗漏出错，但只要从大到小排序，就不会有遗漏情况了

#include <iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=1010;
int a[maxn];
bool cmp(int a,int b)
{
    return a>b;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        for(int i=0; i<n; i++)
            cin>>a[i];
        sort(a,a+n,cmp);
        int flag=0;
        int k=2048;
        int sum=0;
        for(int i=0; i<n; i++)
        {
            if(k>=a[i]&&k%a[i]==0)
                sum+=a[i];
            
            if(sum==k)
            {
                flag=1;
                break;
            }
        }
        if(flag)
             printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

题意：n行n列中有些骑士，他们的攻击方式为象棋里的马，问n行n列里，怎么安排可以使得攻击次数最多

思路：有规律的题，一行BWBW下面一行WBWB循环，多补少减

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
int a[105][105];
int main()
{
    int n;
	cin>>n;
    for(int i = 1;i <= n;i++)
    {
        for(int j = 1;j <= n;j++)
        {
            if(i&1)
            {
                if(j&1)
                     printf("W");
                else printf("B");
            }
            else
            {
                if(j & 1)
                     printf("B");
                else printf("W");
            }
        }
        printf("\n");
    }
    return 0;
}

题意：有n个栏杆，每个栏杆都有原始高度和增加一米的价格，求让每两个相邻的栏杆高度不同的最小代价。

思路：由于我太菜，这题用dp好像挺简单，dp[i][j]表示在第i个栏杆增加j的代价加上满足之前所有栏杆不同的代价然后状态转移方程就是dp[i][j]=min(dp[i][j],dp[i-1][k]+j*a[i].w)也是相当于比较相邻的两个让哪个增加更好一点。

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

typedef long long ll;
const int N=3e5+1000;
struct Node{
	ll h,w;
}a[N];
ll dp[N][4];
int main()
{
//一定关闭输入输出流，不然会超时
	std::ios::sync_with_stdio(false);
	int t;
	cin>>t;
	while(t--)
	{
		int n;
		cin>>n;
		for(int i=1;i<=n;i++)
		cin>>a[i].h>>a[i].w;
		for(int i=1;i<=n;i++)
		dp[i][0]=dp[i][1]=dp[i][2]=1e18; 
		
		dp[1][0]=0;
		dp[1][1]=a[1].w;
		dp[1][2]=a[1].w*2;
		for(int i=2;i<=n;i++)
		{
			for(int j=0;j<3;j++)
			{
				for(int k=0;k<3;k++)
				{
				//保证第i棵树和第i-1棵树高度不会相等，然后开始动态规划判断求最小
					if((a[i-1].h+k)!=(a[i].h+j))
					{
			
						dp[i][j]=min(dp[i][j],dp[i-1][k]+j*a[i].w);
					}
				}
			}
		}
		//输出最小值
		cout<<min(dp[n][0],min(dp[n][1],dp[n][2]))<<endl;
	}
	return 0;
}