ecjtu-summertraining #10

A UVA - 10954

将n个数合并成一个数，每次合并的价值是两个数的和，求最小的总和价值。

优先队列。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
#define ll long long
int main(){
    ll n,num;
    while(scanf("%lld",&n)&&n) {
        priority_queue<ll, vector<ll>, greater<ll> >que;
        for(int i = 1; i <= n; i ++)cin>>num,que.push(num);
        if(que.size()==1){
            cout << 0 << endl;
            continue;
        }
        ll sum = 0;
        while(que.size() != 1){
            ll a = que.top();
            que.pop();
            ll cnt = que.top();
            que.pop();
            ll ans = a+cnt;
            sum+=ans;
            que.push(ans);
        }
        printf("%lld
",sum);
    }
    return 0;
}

B - Calendar Game

Description

Adam and Eve enter this year's ACM International Collegiate Programming Contest. Last night, they played the Calendar Game, in celebration of this contest. This game consists of the dates from January 1, 1900 to November 4, 2001, the contest day. The game starts by randomly choosing a date from this interval. Then, the players, Adam and Eve, make moves in their turn with Adam moving first: Adam, Eve, Adam, Eve, etc. There is only one rule for moves and it is simple: from a current date, a player in his/her turn can move either to the next calendar date or the same day of the next month. When the next month does not have the same day, the player moves only to the next calendar date. For example, from December 19, 1924, you can move either to December 20, 1924, the next calendar date, or January 19, 1925, the same day of the next month. From January 31 2001, however, you can move only to February 1, 2001, because February 31, 2001 is invalid.

A player wins the game when he/she exactly reaches the date of November 4, 2001. If a player moves to a date after November 4, 2001, he/she looses the game.

Write a program that decides whether, given an initial date, Adam, the first mover, has a winning strategy.

For this game, you need to identify leap years, where February has 29 days. In the Gregorian calendar, leap years occur in years exactly divisible by four. So, 1993, 1994, and 1995 are not leap years, while 1992 and 1996 are leap years. Additionally, the years ending with 00 are leap years only if they are divisible by 400. So, 1700, 1800, 1900, 2100, and 2200 are not leap years, while 1600, 2000, and 2400 are leap years.

Input

The input consists of T test cases. The number of test cases (T ) is given in the first line of the input file. Each test case is written in a line and corresponds to an initial date. The three integers in a line, YYYY MM DD, represent the date of the DD-th day of MM-th month in the year of YYYY. Remember that initial dates are randomly chosen from the interval between January 1, 1900 and November 4, 2001.

Output

Print exactly one line for each test case. The line should contain the answer "YES" or "NO" to the question of whether Adam has a winning strategy against Eve. Since we have T test cases, your program should output totally T lines of "YES" or "NO".

Sample Input

3 
2001 11 3 
2001 11 2 
2001 10 3 

Sample Output

YES
NO
NO
博弈论，m+d是偶数就是yes，9月30和11月30要特判下。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define ll long long
using namespace std;

int main() {
    int t,y,m,d;
    scanf("%d",&t);
    while(t--) {
        scanf("%d%d%d",&y,&m,&d);
        if((m+d)%2 ==0 || (m==9&&d==30) || (m==11&&d==30))
            puts("YES");
        else puts("NO");  
    }
    return 0;
}

C - Assemble

Problem Description

Recently your team noticed that the computer you use to practice for programming contests is not good enough anymore. Therefore, you decide to buy a new computer.

To make the ideal computer for your needs, you decide to buy separate components and assemble the computer yourself. You need to buy exactly one of each type of component.

The problem is which components to buy. As you all know, the quality of a computer is equal to the quality of its weakest component. Therefore, you want to maximize the quality of the component with the lowest quality, while not exceeding your budget.

 

Input

On the first line one positive number: the number of testcases, at most 100. After that per testcase:

One line with two integers: 1 ≤ n ≤ 1 000, the number of available components and 1 ≤ b ≤ 1 000 000 000, your budget.

n lines in the following format: “type name price quality”, where type is a string with the type of the component, name is a string with the unique name of the component, price is an integer (0 ≤ price ≤ 1 000 000) which represents the price of the component and quality is an integer (0 ≤ quality ≤ 1 000 000 000) which represents the quality of the component (higher is better). The strings contain only letters, digits and underscores and have a maximal length of 20 characters.

 

Output

Per testcase:

One line with one integer: the maximal possible quality.

 

Sample Input

1

18 800

processor 3500_MHz 66 5

processor 4200_MHz 103 7

processor 5000_MHz 156 9

processor 6000_MHz 219 12

memory 1_GB 35 3

memory 2_GB 88 6

memory 4_GB 170 12

mainbord all_onboard 52 10

harddisk 250_GB 54 10

harddisk 500_FB 99 12

casing midi 36 10

monitor 17_inch 157 5

monitor 19_inch 175 7

monitor 20_inch 210 9

monitor 22_inch 293 12

mouse cordless_optical 18 12

mouse microsoft 30 9

keyboard office 4 10

 

Sample Output

9

 

有b元，每种类型的要买一种，每种有个价格和质量，在b元内买的类型中，质量最小的最大化是多少。比赛时想不出怎么贪心，

赛后看了题解发现是二分+贪心，然后就知道做了，真是不看题解不知道，一看就知道，要多刷题刷题了。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <map>
#include <vector>
#define ll long long
using namespace std;
struct Nod{
    int c,q;
}t;
map<string,int>mp;
vector<Nod> vs[1010];
int a[1010], T, n, k, b;
bool check(int m) {
    ll x = 0;
    for(int i = 0; i < k; i ++){
        int mins = 0x3f3f3f3f;
        for(int j = 0; j < vs[i].size(); j ++) {
            if(vs[i][j].q >= m){
                mins = min(mins,vs[i][j].c);
            }
        }
        if(mins == 0x3f3f3f3f)return false;
        x += mins;
        if(x > b) return false;
    }
    return x <= b;
}
int main() {
    std::ios::sync_with_stdio(false);
    scanf("%d",&T);
    while(T--) {
        mp.clear();
        char ss[100], s[100];
        string sss;
        k = 0;
        scanf("%d%d",&n,&b);
        for(int i = 0; i <= n; i ++)vs[i].clear();
        for(int i = 0; i < n; i ++){
            scanf("%s%s%d%d",ss,s,&t.c,&t.q);
            sss = ss;a[i] = t.q;
            if(!mp.count(sss)){
                mp[sss] = k++;
            }
            vs[mp[sss]].push_back(t);
        }
        sort(a,a+n);
        int l = 0, r = n-1,ans = 0;
        while(l <= r) {
            int m = (l+r)>>1;
            if(check(a[m])){
                ans = a[m];
                l=m+1;
            }
            else r = m-1;
        }
        printf("%d
",ans);
    }
    return 0;
}

D - Detachment

将一个数n分成a1+a2+a3....+ak = n的形式，但a1!=a2!=a3...!=ak，求s=a1*a2*a3...*ak的最大值。

 

关键在于怎么让s最大化，而一段连续的数字可以是值最大化，证明就不说了。让n分为2*3*4*..*k的形式就行。

不过n是10^9内的数字，不可能全部正好等于2*3*4...的形式，可能会多出△x，而这个△x的值，我可以保证它的范围为0≤△x≤k

那么有三种情况。

1、△x = k, 比如2*3*4*5 多出一个5 那么可以变成3*4*5*7

2、△x = 0,那就好办了，答案就是k!

3、0< △x < k ,比如3*4*5*6 多出一个3，那么就可以变成3*5*6*7。

拿第三种情况来说，这个的答案是7!*3!/(2!*4!)，这里要对除法进行取摸运算，乘法的到可以直接算，除法的就不行了，要用到乘法逆元。

直接丢公式：

满足b*k≡1 (mod MOD)   即b*k%MOD==1%MOD==1的k值就是b关于MOD的乘法逆元。也就是(a/b)%MOD==(a*k)%MOD

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define ll long long
using namespace std;
const int mod = 1e9+7;
const int MAX = 1e5;
ll mul[MAX], add[MAX];

void exgcd(ll a, ll b, ll &x, ll &y) {
    if(!b){
        x = 1; y = 0;
    }else{
        exgcd(b, a%b, y, x);
        y -= x*(a/b);
    }
}
ll inv(ll a, ll n) {
    ll x, y;
    exgcd(a, n, x, y);
    return (x+n)%n;
}
void init() {
    add[0] = add[1] = 0;
    add[2] = 2;
    mul[0] = mul[1] = 1;
    mul[2] = 2;
    for(int i = 3; i < MAX; i ++) {
        add[i] = add[i-1] + i;
        mul[i] = (mul[i-1]*i)%mod;
    }
}
int main() {
    //std::ios::sync_with_stdio(false);
    int t;
    ll n;
    scanf("%d",&t);
    init();
    while(t--) {
        scanf("%lld",&n);
        if(n <= 4){
            printf("%lld
",n);
            continue;
        }
        int l = 2, r = MAX - 5;
        while(l < r) {
            int m = (l+r+1) >> 1;
            if(add[m] <= n) l = m;
            else r = m-1;
        }
        ll tmp = n-add[l];
        if(tmp == l) printf("%lld
",mul[l]*inv(2,mod)%mod*(l+2)%mod);
        else if(tmp == 0) printf("%lld
",mul[l]);
        else printf("%lld
",mul[l-tmp]*mul[l+1]%mod*inv(mul[l-tmp+1],mod)%mod);
    }
    return 0;
}

E - Revenge of Fibonacci

题目给出斐波那契数列的前k位，k不超过40，找出最小的正整数n，满足F(n)的前k位与给定数的前k位相同，斐波那契数列的项数不超过100000。超过则输出 -1

这题是最气的，想了好久，在比赛一半是想到了用字典树来做，不过大数加法+字典树却写了我快一个小时，好久不写都生疏了，问题是提交一直错误。

就只能等赛后看题解了，发现两个问题，1、他的最大值要小于100000，那我非作死的加了一个10，习惯性的加10，让我过不了，还有一个是能用字符数组就用字符数组，坚决不用字符串，输入字符串最大才40个，而我用字符串死活过不去，无意间改成字符数组就过了。。。

在做的时候 两个加数 只要前40去做加法存在字典树里就行了，不过我让它长度大于100在去截取前面50个，能保证不会出现加法错误。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define ll long long
using namespace std;
const int MAX = 2e5+10;
struct Nod{
    Nod* nex[11];
    int id;
    Nod(){
        for(int i = 0; i < 10; i ++)
            nex[i] = NULL;
            id = -1;
    }
}t;
string s,ss;
void mkTrie(string s, int id){
    Nod *p = &t;
    for(int i = 0; i < s.length(); i ++){
        int x = s[i] - '0';
        if(p->nex[x] == NULL){
            p->nex[x] = new Nod;
        }
        p = p->nex[x];
        if(p->id == -1)
            p->id = id;
    }
}
int find(char* s){
    Nod *p = &t;
    for(int i = 0;s[i]; i ++) {
        int x = s[i] - '0';
        if(p->nex[x] == NULL) return -1;
        p = p->nex[x];
    }
    return p->id;
}
string add(string s, string ss) {
    reverse(s.begin(),s.end());
    reverse(ss.begin(),ss.end());
    int flag = 0;
    if(s.length() > ss.length()){
        swap(s,ss);
    }
    int len1 = s.length(), len2 = ss.length();
    string sss = "";
//    cout << ss << ' ' << s << endl;
    for(int i = 0; i < len2; i ++){
        int b = ss[i] - '0', a;
        if(i < len1){
            a = s[i] - '0';
        }else a = 0;
        int c = a+b+flag;
        if(c > 9){
            sss += c-10+'0';
            flag = 1;
        }else {
            sss += c +'0';
            flag = 0;
        }
    }
    if(flag) sss += '1';
    reverse(sss.begin(),sss.end());
    return sss;
}
void init() {
    s = "1"; ss = "1";
    mkTrie(s,0);mkTrie(ss,1);
    for(int i = 2; i < 100000; i ++){
        if(s.length() > 100){
            reverse(s.begin(),s.end());
            reverse(ss.begin(),ss.end());
            s = s.substr(50,1000);
            ss = ss.substr(50,1000);
            reverse(s.begin(),s.end());
            reverse(ss.begin(),ss.end());
        }
        string sss = add(s,ss);
        mkTrie(sss,i);
        s = ss;
        ss = sss;
    }
}

int main() {
    //std::ios::sync_with_stdio(false);
    init();
    int t;
    scanf("%d",&t);
    for(int i = 1; i <= t; i ++) {
        char s[60];//这里一定要用字符数组，用string就会答案错误。不知道怎么一回事。
        scanf("%s",s);
        printf("Case #%d: %d
",i,find(s));
    }
    return 0;
}