暑假嗨7.9

最新推荐文章于 2024-09-09 16:49:53 发布

s4ul

最新推荐文章于 2024-09-09 16:49:53 发布

阅读量113

点赞数 1

分类专栏： div3

本文链接：https://blog.csdn.net/zhaochuanfei666/article/details/107239033

版权

div3 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

A
题意：有一队人，其中有两个仇人，你的任务是在给定的交换次数的情况下，让这俩人离得越远越好，交换一次是相邻两两交换。

#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <stack>
#include <queue>

using namespace std;
#define mod 1e9+7
#define N 1000001
#define inf 0x3f3f3f3f
const double PI = atan(1.0)*4.0;
typedef long long ll;
//char a[N],b[N];

int main()
{
    std::ios::sync_with_stdio(false);
   // freopen("E:\\in.txt","r",stdin);
    int t;
    cin>>t;
    while(t--)
    {
        int a,b,c,d;
        cin>>a>>b>>c>>d;
        if(d<c)swap(d,c);
        int x=c-1;
        int y=a-d;
        if((x+y)<=b)
            cout<<a-1<<endl;
        else
            cout<<d-c+b<<endl;

    }





}

B
跟昨天的题一样。
C
题意：
给定一段数，问距离最近的两个相同的数的距离

#include <queue>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <stack>
#include <queue>

using namespace std;
#define mod 1e9+7
#define N 200005
#define inf 0x3f3f3f3f
const double PI = atan(1.0)*4.0;
typedef long long ll;
int a[N],dp[N],pos[N];

int main()
{
    std::ios::sync_with_stdio(false);
   // freopen("E:\\in.txt","r",stdin);
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        for(int i=1;i<=n;i++)
        {dp[i]=inf;pos[i]=0;}
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];

        }
        for(int i=1;i<=n;i++)
        {  if(pos[a[i]]!=0)
             dp[a[i]]=min(dp[a[i]],i-pos[a[i]]+1);



              pos[a[i]]=i;
        }int minn=inf;
        for(int i=1;i<=n;i++)
           minn=min(dp[i],minn);
        if(minn==inf)cout<<-1<<endl;
        else cout<<minn<<endl;
    }

}

进化，降低了时间复杂度

#include <queue>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <stack>
#include <queue>
#include <cstdio>
 
using namespace std;
#define mod 1e9+7
#define N 200005
#define inf 0x3f3f3f3f
const double PI = atan(1.0)*4.0;
typedef long long ll;
int a[N],pos[N],dp=inf;
 
int main()
{
    std::ios::sync_with_stdio(false);
   // freopen("E:\\in.txt","r",stdin);
  // int a[N],pos[N],dp;
    int t;
    cin>>t;
    while(t--)
    {dp=inf;
        int n;
        cin>>n;
        for(int i=1;i<=n;i++)
        {pos[i]=0;}
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            if(pos[a[i]]==0)
             pos[a[i]]=i;
 
        }
        for(int i=1;i<=n;i++)
        {  if(pos[a[i]]!=0&&i!=pos[a[i]])
             dp=min(dp,i-pos[a[i]]+1);
 
 
 
              pos[a[i]]=i;
        }
        if(dp==inf)cout<<-1<<endl;
        else cout<<dp<<endl;
    }
 
}

D
题意：
你有若干英雄，每个英雄有两个属性，能力和耐力，现在你要派某个英雄去打怪，只能派一个，每个怪兽都有一个耐力值，英雄的能力值大于等于怪兽能力值则能打过，打一个怪消耗一个耐力值，当耐力值耗尽或能力值小于当前怪的时候，英雄回来，一天只能派一个英雄，一个英雄可以被派遣多次，问最少需要多少天打完所有怪。
思路：
1.首先对英雄的攻击里排序，如果攻击力一样就看耐力，再从后往前遍历，求出攻击力大于heros[i].p的所有英雄的最大耐力是多少，存入c[i]中
2.按顺序去遍历怪物，用一个mmax来存下消灭到当前怪物要达到的攻击力是多少，一个len来存要消灭的怪物的数量，其实就是要消灭的怪物中的最大攻击力是多少，然后用二分查找，找出第一个攻击力大于mmax的英雄，下标位idx，那么我们只要判断c[idx]是否比要消灭的怪物的数量len小，如果小，就表示前面一个怪物是能一次性消灭的最多的怪物的最后一个，那么ans++，并且mmax=mos[i]，表示重新开始一天，len=1，直到遍历完所有怪物。
3.如果最大怪物的攻击力大于最大英雄的攻击力，那么表示不能通关，输出-1

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include <iostream>
using namespace std;
#define ll long long
int n, m;
const int N = 2e5+5;
struct hero
{
    int p;
    int s;
    bool operator < (const hero& b)const
    {
        return p < b.p || ((p == b.p)&&s < b.s);
    }
} heros[N];
int mos[N];
int c[N];
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        cin >> n;
        int tmax = 0;
        for (int i = 1; i <= n; i++)
        {
            scanf_s("%d", &mos[i]);
            tmax = max(tmax, mos[i]);
        }
        cin >> m;
        for (int i = 1; i <= m; i++)
        {
            scanf_s("%d%d", &heros[i].p, &heros[i].s);
        }
        int mmax = 0;
        int ans = 0;
        sort(heros + 1, heros + m + 1);
        for (int i = m; i >= 1; i--)
        {
            mmax = max(mmax, heros[i].s);
            c[i] = mmax;
        }
        if (heros[m].p < tmax)
        {
            ans = -1;
        }
        else
        {
            mmax = 0;
            int len = 0;
            for (int i = 1; i <= n; i++)
            {
                mmax = max(mos[i], mmax);
                len++;
                int l = 1, r = m;
                while (l < r)
                {
                    int mid = (l + r) >> 1;
                    if (heros[mid].p >= mmax)
                    {
                        r = mid;
                    }
                    else
                    {
                        l = mid + 1;
                    }
                }
                if (c[l] < len)
                {
                    ans++;
                    mmax = mos[i];
                    len = 1;
                }
            }
            ans++;
        }
        cout << ans << "\n";
    }
    return 0;
}

E
题意：
初始有三个组，共n个数，现在要求改变一些数的位置，使得第一个组为这n个数的前缀，第三个组为这n个数的后缀，第二个组为其余数字，移动后一些组可能为空，要求最少移动次数。
思路：
按照顺序，前一个数字所放的组的编号会影响到后续数字放的组的编号，比如如果数字1 放第三组，那么后续n−1 个数组也就只能放第三组，但如果数字1 放第二组，那么数字二就有两个选择：放第二组或放第三组。依次来看，后一个数字的位置状态受到前一个数字位置状态的影响，所以可以通过动态规划来枚举每个数字的位置状态，来求出这n 个数字的最小移动次数。
假设数字i原来所在的组数为a[i] ，也就是输入时的位置。
我们定义: dp[i][j] 为轮到了数字i选组，数字i 选第j组后的最小移动次数，那么我们可以得到状态转移方程：
(1) dp[i][1]=dp[i−1][1]+(a[i]!=1)
(2) dp[i][2]=min(dp[i−1][1],dp[i−1][2])+(a[i]!=2)
(3) dp[i][3]=min(dp[i−1][1],dp[i−1][2],dp[i−1][3])+(a[i]!=3) //可能第二组为空，所以前一个数在第一组
所以n个数的最小移动次数即为dp[n][1],dp[n][2],dp[n][3]中的较小者。
代码：

#include <bits/stdc++.h>

using namespace std;
const int maxn=2e5+7;
typedef long long ll;
const int inf=0x3f3f3f3f;
int k1,k2,k3,n,x;
int a[maxn],dp[maxn][5];
int main()
{
    scanf("%d%d%d",&k1,&k2,&k3);
    n=k1+k2+k3;
    for(int i=1;i<=n;i++){
        dp[i][1]=dp[i][2]=dp[i][3]=inf;//初始化dp数组为无穷大
        scanf("%d",&x);
        if(i<=k1)a[x]=1;//数字x原来所在的组数为a[x]
        else if(i<=k1+k2)a[x]=2;
        else a[x]=3;
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=3;j++){//枚举前一个数字所在的组数
            for(int k=j;k<=3;k++){//枚举后一个数字所在的组数
                dp[i][k]=min(dp[i][k],dp[i-1][j]+(a[i]!=k));
            }
        }
    }
    cout<<min(dp[n][1],min(dp[n][2],dp[n][3]))<<'\n';
    return 0;
}