2018 Spring Team Contest D HDU - 6023、HDU - 6024、HDU - 6025 、HDU - 6027 、HDU - 6029

最新推荐文章于 2018-07-23 20:49:22 发布
最新推荐文章于 2018-07-23 20:49:22 发布
阅读量307 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxy201658506207/article/details/80159081
版权

  HDU - 6023  //编译错误不算罚时

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int vis[100];
int num[20];
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,m;
        cin>>n>>m;
        int id,h1,f1;
        char str[5];
        int cnt=0,sum=0;
        memset(vis,0,sizeof(vis));
        memset(num,0,sizeof(num));
        for(int i=0;i<m;i++)
        {
            scanf("%d",&id);
            scanf("%d",&h1);
            getchar();
            scanf("%d",&f1);
            scanf("%s",str);
            id=id-1000;
            if(vis[id]==1)continue;
            if(strcmp(str,"AC")==0)
            {
                vis[id]=1;
                sum+=h1*60+f1+num[id];
            }
            else
                num[id]+=20;
        }
        for(int i=0;i<=n;i++)
            if(vis[i]==1)
            cnt++;
        cout<<cnt<<" "<<sum<<endl;
    }
    return 0;
}

HDU - 6024

HDU’s  nn classrooms are on a line ,which can be considered as a number line. Each classroom has a coordinate. Now Little Q wants to build several candy shops in these  nn classrooms. 

The total cost consists of two parts. Building a candy shop at classroom  ii would have some cost  cici. For every classroom  PP without any candy shop, then the distance between  PP and the rightmost classroom with a candy shop on  PP's left side would be included in the cost too. Obviously, if there is a classroom without any candy shop, there must be a candy shop on its left side. 

Now Little Q wants to know how to build the candy shops with the minimal cost. Please write a program to help him. 
InputThe input contains several test cases, no more than 10 test cases. 
In each test case, the first line contains an integer  n(1≤n≤3000)n(1≤n≤3000), denoting the number of the classrooms. 
In the following  nn lines, each line contains two integers  xi,ci(−109≤xi,ci≤109)xi,ci(−109≤xi,ci≤109), denoting the coordinate of the  ii-th classroom and the cost of building a candy shop in it. 
There are no two classrooms having same coordinate.OutputFor each test case, print a single line containing an integer, denoting the minimal cost.Sample Input 
3
1 2
2 3
3 4
4
1 7
3 1
5 10
6 1
Sample Output 
5
11

题意是，花费的代价是：要是在这个位置上建立糖果屋就花菲建糖果屋的代价，要不就在这个位置上建糖果屋花费的代价就是，这个屋子的坐标减去离他最近的建糖果屋的坐标，还有最左面的屋子一定要建立糖果屋的。

不是贪心的题：

举个反例：

当输入     5

1 2

2 2

3 2

4 3

5 4

的时候，在2这个做标处，按照贪心处理的话不会在这个坐标建糖果屋，花费是： 2+1+2+3+4， 而选择建的话是 2+2+1+2+3+4，所以贪心的思想是错误的。

点击打开题解链接

#include<iostream>
#include<algorithm>
#include<cstring>
#include <cstdio>
//#include <bits/stdc++.h>
#define INF  0x3f3f3f3f
#define LL long long
//#define IO ios::sync_with_stdio(false);
using namespace std;
LL dp[3005][2];
struct node
{
    LL id;
    LL cost;

}s[3005];
bool cmp(node a,node b)
{
    return a.id<b.id;
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)//不加EOF TLE！
    {
        for(int i=0;i<n;++i)
        {
            //cin>>s[i].id>>s[i].cost;
            scanf("%lld%lld",&s[i].id,&s[i].cost);
        }
        sort(s,s+n,cmp);
        memset(dp,INF,sizeof(dp));
        dp[0][1]=s[0].cost;
        for(int i=1;i<n;++i)
        {
            dp[i][1]=min(dp[i-1][0],dp[i-1][1])+s[i].cost;
            LL ans=0;
            for(int j=i-1;j>=0;--j)
            {
                ans+=(s[j+1].id-s[j].id)*(i-j);
                dp[i][0]=min(dp[j][1]+ans,dp[i][0]);
            }
        }
        printf("%lld\n",min(dp[n-1][1],dp[n-1][0]));
      // cout<<min(dp[n-1][0],dp[n-1][1])<<endl;
    }
    return 0;
}
#include<iostream>
#include<algorithm>
#include <cstdio>
//#include <bits/stdc++.h>
#include <cstring>
#define INF  0x3f3f3f3f //用1e20就不对
//#define IO ios::sync_with_stdio(false);
using namespace std;
long long dp[3005][2]={0};
long long dis[3005][3005];
struct node
{
    int id;
    int cost;
    bool operator <(const node &b)const
    {
        return id<b.id;
    }
}s[3005];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;++i)
        {
            scanf("%d%d",&s[i].id,&s[i].cost);
        }
        sort(s+1,s+n+1);
        memset(dis,0,sizeof(dis));
        memset(dp,INF,sizeof(dp));
       for(int i=1;i<=n;++i)
        {
            for(int j=1;j<i;++j)
                if(i!=j)
                dis[j][i]=dis[j][i-1]+s[i].id-s[j].id;//(1+i-j)*(i-j)*0.5;
        }
        // for(int i=1;i<=n;++i)
      //  {
       //     for(int j=i+1;j<=n;++j)
          //      dis[i][j]=dis[i][j-1]+s[j].id-s[i].id;//(1+i-j)*(i-j)*0.5;
       // }
        dp[1][1]=s[1].cost;
        for(int i=2;i<=n;++i)
        {
            dp[i][1]=min(dp[i-1][0],dp[i-1][1])+s[i].cost;
            for(int j=i-1;j;--j)
            {
                dp[i][0]=min(dp[i][0],dp[j][1]+dis[j][i]);
            }
        }
        long long MIN=min(dp[n][0],dp[n][1]);
        printf("%I64d\n",MIN);
    }
    return 0;
}

HDU - 6025 :

Do you know what is called ``Coprime Sequence''? That is a sequence consists of  nnpositive integers, and the GCD (Greatest Common Divisor) of them is equal to 1. 
``Coprime Sequence'' is easy to find because of its restriction. But we can try to maximize the GCD of these integers by removing exactly one integer. Now given a sequence, please maximize the GCD of its elements.
InputThe first line of the input contains an integer  T(1≤T≤10)T(1≤T≤10), denoting the number of test cases. 
In each test case, there is an integer  n(3≤n≤100000)n(3≤n≤100000) in the first line, denoting the number of integers in the sequence. 
Then the following line consists of  nn integers  a1,a2,...,an(1≤ai≤109)a1,a2,...,an(1≤ai≤109), denoting the elements in the sequence.OutputFor each test case, print a single line containing a single integer, denoting the maximum GCD.Sample Input 
3
3
1 1 1
5
2 2 2 3 2
4
1 2 4 8
Sample Output 
1
2
2

用公约数的前缀和和后缀方法：

总结：求一串数字的最大公约数和数字的顺序无关，

//#include<iostream>
//#include<algorithm>
//#include <cstdio>
#include <bits/stdc++.h>
using namespace std;
  //long long dp[3005][3005]={0};
int num[100005];
int pre[100005];
int nre[100005];
int _gcd(int a,int b)
{
    return b?_gcd(b,a%b):a;
}
int main()
{
    int Case,n;
    cin>>Case;
    for(int t=0;t<Case;++t){

            scanf("%d",&n);

        for(int i=0;i<n;++i)
            scanf("%d",&num[i]);

        pre[0]=num[0];
        nre[n-1]=num[n-1];

        for(int i=1;i<n;++i)
        {
            pre[i]=_gcd(pre[i-1],num[i]);
        }
        for(int i=n-2;i>=0;--i)
        {
            nre[i]=_gcd(nre[i+1],num[i]);
        }

        int MAX=max(pre[n-2],nre[1]);

        for(int i=1;i<n-1;++i)
        {
            MAX=max(MAX,_gcd(pre[i-1],nre[i+1]));
        }
        printf("%d\n",MAX);
    }
    return 0;
}

用的一种找规律的方法，这道题就让去掉一个数字然后求他们的最大公约数，那么你不管怎么去（偏大的还是偏小的）那个数字，剩下的数字的最大公约数肯定是小于这个数字串的最小的那个数字，可以从数字串a的a1位置开始暴力，（要是去掉2个数字，可以从a2位置的数字开始枚举，不过去除的数字太多的话，应该会TLE,所以不如上面的求前缀后缀的方法好）

#include<iostream>
#include<algorithm>
using namespace std;

int main()
{
    int t;
    cin>>t;
    int n;
    int a[100005];
    while(t--)
    {
        cin>>n;
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
        }
        sort(a,a+n);
        int h=a[1];
        int flag=0;
        for(int j=h;j>=1;j--)
        {
            int sum=0;
            for(int i=0;i<n;i++)
            {
                if(a[i]%j==0)
                    sum++;
                if(sum>=n-1)
                {
                    flag=1;
                    cout<<j<<endl;
                    break;
                }
            }
            if(flag==1)
                break;
        }
    }
    return 0;
}
（队友提到一道题，给你n个数字求他们的最大公因子是多少：从他们的最小的那个数字n开始找到1要是中间的有个数字%==0这个数字串的次数为数字串的个数，就是这个串的最大公约数）

HDU - 6027 

You are encountered with a traditional problem concerning the sums of powers. 
Given two integers  nn and  kk. Let  f(i)=ikf(i)=ik, please evaluate the sum  f(1)+f(2)+...+f(n)f(1)+f(2)+...+f(n). The problem is simple as it looks, apart from the value of  nnin this question is quite large. 
Can you figure the answer out? Since the answer may be too large, please output the answer modulo  109+7109+7.
InputThe first line of the input contains an integer  T(1≤T≤20)T(1≤T≤20), denoting the number of test cases. 
Each of the following  TT lines contains two integers  n(1≤n≤10000)n(1≤n≤10000) and  k(0≤k≤5)k(0≤k≤5). 
OutputFor each test case, print a single line containing an integer modulo  109+7109+7.Sample Input 
3
2 5
4 2
4 1
Sample Output 
33
30
10

大数，

import java.util.*;
import java.math.*;
public class Main{
public static void main(String args[]) {  
  
    Scanner cin=new Scanner (System.in);
    int n;
    n=cin.nextInt();
    //BigInteger a;
    int a;
    int k;
   BigInteger MOD=new  BigInteger("1000000007");
    for(int i=0;i<n;++i)
    {
        BigInteger sum=BigInteger.ZERO;
        a=cin.nextInt();
        k=cin.nextInt();
        BigInteger j=BigInteger.ONE;//=new BigInteger("1");
        for(int m=0;m<a;m++)
        {
          
          //  System.out.println();
            sum=sum.add(j.pow(k));
            sum=sum.mod(MOD); 
            j=j.add(BigInteger.ONE);
            
        }
      System.out.println(sum);
    }
}
}

用快速幂：

#include<iostream>
#include<algorithm>
#include <cstdio>
using namespace std;
const int MOD = 7+1e9;
//#define  MOD 1e9+7 越界了
long long  n,k;
long long POW(long long  p,long long x)
{
    long long ans=1;
    while(x)
    {
        if(x&1)
            ans=(ans*p)%MOD;

        p=(p*p)%MOD;
        x>>=1;
    }
    return ans;
}
int main()
{
    long long  t;
    cin>>t;
   while(t--)
   {
        long long sum=0;
        cin>>n>>k;
        for(long long  p=1;p<=n;++p)
        {
            sum=(sum+POW(p,k))%MOD;
        }
        //printf("%lld\n",sum);
        cout<<sum<<endl;
    }
    return 0;
}

Graph Theory

  HDU - 6029

Little Q loves playing with different kinds of graphs very much. One day he thought about an interesting category of graphs called ``Cool Graph'', which are generated in the following way: 
Let the set of vertices be {1, 2, 3, ...,  nn}. You have to consider every vertice from left to right (i.e. from vertice 2 to  nn). At vertice  ii, you must make one of the following two decisions: 
(1) Add edges between this vertex and all the previous vertices (i.e. from vertex 1 to  i−1i−1). 
(2) Not add any edge between this vertex and any of the previous vertices. 
In the mathematical discipline of graph theory, a matching in a graph is a set of edges without common vertices. A perfect matching is a matching that each vertice is covered by an edge in the set. 
Now Little Q is interested in checking whether a ''Cool Graph'' has perfect matching. Please write a program to help him. 
InputThe first line of the input contains an integer  T(1≤T≤50)T(1≤T≤50), denoting the number of test cases. 
In each test case, there is an integer  n(2≤n≤100000)n(2≤n≤100000) in the first line, denoting the number of vertices of the graph. 
The following line contains  n−1n−1 integers  a2,a3,...,an(1≤ai≤2)a2,a3,...,an(1≤ai≤2), denoting the decision on each vertice.OutputFor each test case, output a string in the first line. If the graph has perfect matching, output ''Yes'', otherwise output ''No''. 
Sample Input 
3
2
1
2
2
4
1 1 2
Sample Output 
Yes
No
No

意思是给你一个数n代表有n个顶点（1,2,3.....n)，然后再给你n-1个数字代表对顶点2,3,4,,,,n所做的操作，操作有两种形式，1和2

1代表把当前顶点（ai)及其之前的顶点都加上一条边，可以放到一个集合里面（边往集合哩放的条件是，这个边的两个顶点在这个集合里面都没有出现过）2这个操作代表这个点是个孤立的顶点不给他加边，然后问到最后那个集合里面是不是包含这n个所有顶点。mmp

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,op;
        cin>>n;
      //  int edge[100005]={0};
        int mgj=0;//统计没加进去的点的个数
        for(int i=2;i<=n;++i)
        {
            scanf("%d",&op);//cin>>op;
            if(op==1)
            {
                if(!mgj)
                    mgj=0;
                else
                    mgj--;
            }
            else
                mgj++;
        }

        if(n&1)//奇数构成的边肯定要剩下一个顶点孤立
            printf("No\n");
        else if(!mgj)
           printf("Yes\n");// cout<<"Yes"<<endl;
        else
           printf("No\n");// cout<<"NO"<<endl;
    }
    return 0;
}
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n,order;
        cin>>n;
        int flag=-1,sum=0;//sum统计加进去的个数
        for(int i=2;i<=n;i++)
        {
            cin>>order;
            if(order==1)
            {
                if(sum<i-1)
                sum+=2;
            }
        }
        if(n%2==1)printf("No\n");
        else
        {
            if(sum==n) printf("Yes\n");
            else printf("No\n");
        }
    }
    return 0;
}

小天位
关注
专栏目录
hdu—1004巨坑爹，以后编译用G++而不用C++
kkzmcute的专栏
10-10 854
#include #include #include #include #include #include #define maxn 100 using namespace std; int n; string s; struct Node { string color; int count; }a[maxn]; int sum,Find; void input() {
【细节决定成败】 HDU 最容易犯的错误 持续更新。。。
mmdev
07-21 174
HDU 2023 以后给变量命名尽量用有意义的字符，什么m,n啊，a[xx],b[xx]，c[XX]啊，最容易弄错，刚才就是误把c[x]写成了b[x] 浪费时间 20’ HDU 1200 很简单的水题，处理简单的字符串，但是在模拟示例的输入输出的时候潜意识里把每个字符的宽度弄成了和示例一样 即 char str[201][3] 这样每一行只能保存3个字符。导致后面的错误分都分析不出来...
ACM之编译错误
Zyuchen
03-31 1314
1.Main函数必须返回int类型(正式比赛)2.不要在for语句中定义类型3.__int64不支持，可以用long long代替4.使用了汉语的标点符号5.itoa不是ansi函数，能将整数转换为字符串而且与ANSI标准兼容的方法是使用sprintf()函数        int num = 100;    char str[25];    sprintf(str, " %d" , num);6...
HDU 2037 vc编译问题
vsooda的专栏
02-17 527
vc不通过，提交通过 #include #include struct c { int x; int y; int ord; }d[100]; int cmp(const struct c *a, const struct c *b) {     if ((*a).x == (*b).x)         return (*a).y - (*b).y;     e
hdu1243
Phoebe_Wu2016的博客
03-11 176
反恐训练营 Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 2143Accepted Submission(s): 473 Problem Description 当今国际反恐形势很严峻，特别是美国“9.11事件”以...
2018 Multi-University Training Contest 1 hdu 6304 Chiaki Sequence Revisited（规律？数学？）
abutoto的博客
07-23 240
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6304 题意：看一眼就懂了   做法：找规律，每个数出现的次数k，满足以2^k差为2^k+1的等差数列，然后就可以了，然后正解是差分，阿贝尔变换，本人不会   代码 #include&lt;bits/stdc++.h&gt; #define N 100005 #define P pair&...
2019 Multi-University Training Contest 4(2019hdu多校第六场数据与标程）rar
08-11
在编程竞赛的世界里，HDU（Hangzhou Dianzi University）举办的Multi-University Training Contest一直备受关注，尤其是2019年的第六场赛事，更是吸引了众多参赛者一展才华。这个名为"2019 Multi-University ...
有2019 Multi-University Training Contest 9，hdu多校第9场的题解.zip
08-19
《2019 Multi-University Training Contest 9 HDU多校第9场题解解析》 在编程竞赛的世界中，ACM（国际大学生程序设计竞赛）是一项备受瞩目的活动，它旨在培养学生的算法设计、问题解决和编程能力。2019年，多所大学...
2019 Multi-University Training Contest 4(2019hdu多校第五场数据与标程）.zip
08-11
【标题】"2019 Multi-University Training Contest 4(2019hdu多校第五场数据与标程）.zip" 提供的是一个编程竞赛的数据集和参考解决方案，源自2019年的一场多所大学联合举办的训练比赛。这样的资源对于参与ACM（国际...
HDU acm-PPT课件
06-07
【ACM入门与提高：HDU ACM竞赛课程详解】 ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest，简称ICPC或ACM/ICPC）是一项全球性的竞赛，旨在激发大学生对计算机科学的兴趣，提升他们的...
2019 Multi-University Training Contest 4(2019hdu多校第四场数据与标程).rar
08-01
《2019 Multi-University Training Contest 4：探索ACM竞赛的魅力与技术深度》 在编程竞赛的世界里，ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）无疑是一场盛宴，它考验着参赛者...
acm罚时
热门推荐
lfanchenyu的博客
04-15 2万+
作为一个ACMer，总是习惯于在比赛中或比赛结束后查看自己的排名（Standing），有细心的同学发现Penalty（罚时），在相同做题数下Penalty越小越好（真是个令人振奋的发现）。让我们看看Penatly的计算方法：每道试题用时将从竞赛开始到试题解答被判定为正确（AC）为止，其间每一次提交运行结果被判错误的话将被加罚20分钟时间，未正确解答的试题不记时。例如：A、B两队都正确完成两道题目，
SDUTOJ 2169 Sequence 山东省第二届省赛
emmmmmm
05-05 2093
题目描述 Given an integer number sequence A of length N (1<=N<=1000), we define f(i,j)=(A[i]+A[i+1]+...+A[j])^2 (i<=j). Now you can split the sequence into exactly M (1<=M<= N) succesive parts, and the c
ACM比赛排名与罚时计算问题
lishuzhai的专栏
11-09 1万+
样例：                                                                                                                                                                                                    
rhino grasshoper 框内物体排列（附视频）.gh
最新发布
10-18
【闭合线内物体按方向移动/排列】https://www.bilibili.com/video/BV1z1WfeSEWu?vd_source=b420114c993138474d2e93d83ead77a5
kwant-1.4.3-cp38-cp38-win_amd64.whl
10-18
kwant-1.4.3-cp38-cp38-win_amd64.whl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值