C++博客-Yuan-随笔分类-贪心

CF76B 贪心

_Yuan — Mon, 02 May 2011 15:50:00 GMT

/*
    n<=10^5只mice，m<=10^5个chese分别在两条水平线上
    每只老鼠会选择离它最近的chese，然后同时出发，若到达目标处还有chese，就会吃（几个同时到达的一起吃）
    后来的就没有了
    若有多个，会选择使最后空肚子的mice数最少的那块chese
    问最后有多少只mice要空肚子

    贪心
    对每只老鼠，寻找跟它最近的1个或2个点，设为left,right
    如果left的chese还没被吃或者之前老鼠到达它的时间跟当前这只一样的话，该老鼠不会饿肚子了
    如果之前的老鼠达到它的时间比当前这只长，而且当前这只老鼠只有left这个点最近，那很抱歉，之前那只老鼠没得吃了，
    给这只老鼠吃了
    否则（即有两个最近点），选择右边的chese
    （贪心选左边的，如果左边被人占了，看能不能吃右边的，不能的话，只好跟左边的竞争了，看谁快）

    O(N+M)

    3 1 1 0   --> 2
    1 4 5
    3

    3 3 1 0   --> 0
    -6 -4 -1
    -6 -2 0
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

const int INF =0x3f3f3f3f;
const int MAXN = 100086;

int mice[MAXN], arr[MAXN], chese[MAXN];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
    freopen("out","w",stdout);
#endif

    for (int n, m; ~scanf("%d%d%*d%*d", &n, &m); ) {
        for (int i = 0; i < n; i++) {
            scanf("%d", &mice[i]);
        }
        for (int i = 0; i < m; i ++) {
            scanf("%d", &chese[i]);
        }

        fill(arr, arr+m, INF);
        int ans = 0, now = 0;
        for (int i = 0; i < n ; i ++) {
            while(now + 1 < m && abs(mice[i]-chese[now+1]) < abs(mice[i]-chese[now])){
                now++;
            }
            int left = now , right = now+1 < m
                && abs(mice[i]-chese[now+1]) == abs(mice[i]-chese[now]) ? now+1 : now;
            int dist = abs(mice[i] - chese[left]);
            if(arr[left] == INF) {
                ans ++;
                arr[left] = dist;
            } else if (arr[left] == dist) {
                ans ++;
            } else if(arr[left] > dist && left == right) {//需要left = right
                arr[left] = dist;
            } else if(left != right){
                arr[right] = dist;
                ans++;
            }
        }
        printf("%d\n", n - ans);
    }
    return 0;
}

_Yuan 2011-05-02 23:50 发表评论

CF67B 贪心

_Yuan — Mon, 02 May 2011 06:27:00 GMT

/*
    给出n,k,b[]，n<=1000
    b[i]表示最后要求的一个n的排列中a[]，a[t] =i的这个数左边满足a[j]>=i+k的个数
    求字典序最小的一个满足上面条件排列a[]

    不会贪心，看了别人的
    用类似拓扑排序那样子，每次寻找最小的而且b[i] = 0的输出，  ------------------ Orz
    然后更新b[j], b[j]--
    其中 i>=j+k 因为i已经放在前面了，自然后面的需要a[j]>=i+k的个数就少1了
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for (int n, k; ~scanf("%d%d", &n, &k); ) {
        vector<int> b(n+1);
        for (int i = 1 ; i <= n ; i++) {
            scanf("%d", &b[i]);
        }
        for (int i = 1, j; i <= n; i ++) {
            for(j = 1; j <= n ; j++) {
                if(b[j] == 0){
                    break;
                }
            }
            if(i > 1){
                putchar(' ');
            }
            cout<<j;
            b[j] = -1;
            for (int p = 1; p + k <= j; p++){
                b[p] --;
            }
        }
        cout<<endl;
    }
    return 0;
}

_Yuan 2011-05-02 14:27 发表评论

zoj 3489 贪心

_Yuan — Tue, 26 Apr 2011 08:52:00 GMT

摘要: /**//* 一棵有向树n<=1000 "directed roads" 0是根，现要对其所有边编号，每个点出去的边的编号不能相同这样，0到叶子i就有一条编好号的路径了pathi,要求最小化这些叶子的路径集合{... 阅读全文

_Yuan 2011-04-26 16:52 发表评论

zoj 3474 排序贪心

_Yuan — Wed, 16 Feb 2011 09:51:00 GMT

/*
    主要是，一个能量初始值为S  给出n个要消灭的敌人
    打败每个敌人至少要costi ，然后可以休息，获取体力ri
    问能否打败所有敌人
    n <= 22

    若能打败所有敌人，最后的能量值是唯一的
    即安排一种顺序能打败所有敌人
    对于costi <= ri的，肯定是先打costi比较小的，所以按照costi升序排

    对于costi > ri的，我是按costi降序排，错误
    如
    5
    5 2
    3 3
    然后按照 costi - ri 升序排，也错
    如
    5
    3 2
    5 3

    正确的是按照ri降序排
    解题报告说跟zoj 3077类似，证明挺有启示的
    不是一般性，假设答案的顺序是1,2..,n
                 k-1
    必有 S - ∑(costi - ri) >= costk
                 i=1
        我们可以通过交换所有rj < rj+1的敌人，但最后结果一样！！！
    因为 S' >=  costj , S' - (costj - rj) >=  costj+1
    => S' >= costj+1 , S' - (costj+1  - rj+1) >= costj
    所以像冒泡排序那样交换，最后形成一个r降序的序列，但效果一样

    而zoj 3077按照b降序后，dp选择一部分出来
    效果跟最优解是一样的（最优解其实就是一个集合+一定顺序，而这个顺序跟按照b降序效果一样，
    而选择这个集合就是dp了）

    如果没有没有排序，直接dp就保证不了无后效性
    我想无后效性就是先选a再选b 效果跟先选b再选a，不会因为选择了a就不能选择b了
    所以普通背包问题，按照编号的顺序进行dp就行了

    中大第三本”数字游戏“ 也是先排序，在dp选择
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>

using namespace std;

const int INF = 1000000000;

int main()
{
    int  T;
    for(scanf("%d",&T);T--;){
        int n , S;
        vector<pair<int,int> > less , _less;
        scanf("%d%d",&n,&S);
        for(int i = 0 ; i < n  ; i++){
            int p[3] , r;
            scanf("%d%d%d%d",&p[0],&p[1],&p[2],&r);
            int dp[10];
            fill(dp,dp+10,INF);
            dp[0] = 0;
            for(int i = 0 ; i < 3 ; i++){
                int get = 3 - i;
                for(int j = 0 ; j + get <= 9 ; j++){
                    dp[j+get] = min(dp[j+get] , dp[j] + p[i]);
                }
            }
            int cost = INF;
            for(int j = 7 ; j <= 9 ;j++){
                cost = min(cost , dp[j]);
            }
            if(cost < r ){
                less.push_back(make_pair(cost , r));
            }
            else {
                _less.push_back(make_pair(r , cost));
            }

        }
        sort(less.begin() , less.end());
        sort(_less.begin() , _less.end(),greater<pair<int,int> >());
        for(vector<pair<int,int> >::iterator  it = less.begin() ; it != less.end() ; it++){
            S -= it->first;
            if(S <= 0)break;
            S += it->second;
        }
        for(vector<pair<int,int> >::iterator  it = _less.begin() ; it != _less.end() ; it++){
            S -= it->second;
            if(S <= 0)break;
            S += it->first;
        }
        if(S > 0){
            printf("%d\n",S);
        }
        else {
            puts("no");
        }
    }
    return 0;
}

_Yuan 2011-02-16 17:51 发表评论

C++博客-Yuan-随笔分类-贪心

CF76B 贪心

CF67B 贪心

zoj 3489 贪心

zoj 3474 排序 贪心

zoj 3474 排序贪心