USACO 之 Section 1.3 Greedy Algorithm （已解决）

Mixing Milk：单价越少，买相同数量的牛奶花费越少。。。先排序，再求解。。。

 

/*
ID: Jming
PROG: milk
LANG: C++
*/
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
using namespace std;
int N, M;

struct myNode {
    int P, A;
} node[5005];

bool Cmp(const myNode &n1, const myNode &n2){
    if (n1.A == n2.A) return n1.P < n2.P;
    else return n1.A < n2.A;
}

void Solve() {
    int myCost = 0;
    int myCount = 0;
    for (int i = 0; i < M; ++i) {
        if (myCount + node[i].P > N) {
            myCost += (N-myCount)*node[i].A;
            break;
        }else {
            myCount += node[i].P;
            myCost += node[i].A*node[i].P;
        }
    }
    printf("%d\n", myCost);
}

int main()
{
    freopen("milk.in", "r", stdin);
    freopen("milk.out", "w", stdout);
    scanf("%d %d", &N, &M);
    for (int i = 0; i < M; ++i) {
        scanf("%d %d", &node[i].A, &node[i].P);
    }
    sort(node, node + M, Cmp);
    Solve();
    return 0;
}

 

Barn Repair: 

注意：牛所在的牛棚的编号是乱序的，需要先从小到大排序
分情况讨论：
1）M == 1 ： 最大的牛棚编号 - 最小的牛棚编号 + 1
2）M >= C :  直接输出 C 即可
3）M < C   :  根据各牛棚编号之间的差值，贪心处理（尽量删去差值大的，选取差值小的）

 

/*
ID: Jming
PROG: barn1
LANG: C++
*/

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <functional>
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <queue>
#include <map>
using namespace std;
#define eps 1e-8
#define MAX_C 205

int M, S, C;
int myArr[MAX_C];
vector<int> myVec;

struct myNode {
    int Pos;
    int Dis;
};
myNode node[MAX_C];

bool Cmp(const myNode n1, const myNode n2) {
    return n1.Dis > n2.Dis;
}

void Solve() {
    int myBegin = 0;
    int Sum = 0, tmp;
    myVec.push_back(C-1);
    for (int i = 0; i < myVec.size(); ++i) {
        tmp = myArr[myVec[i]] - myArr[myBegin] + 1;
        if (tmp) Sum += tmp;
        else ++Sum;
        myBegin = myVec[i] + 1;
    }
    printf("%d\n", Sum);
}

int main() {
    freopen("barn1.in", "r", stdin);
    freopen("barn1.out", "w", stdout);
    scanf("%d %d %d", &M, &S, &C);
    for (int i = 0; i < C; ++i) {
        scanf("%d", &myArr[i]);
    }
    sort(myArr, myArr + C);
    for (int i = 1; i < C; ++i) {
        node[i - 1].Pos = i - 1;
        node[i - 1].Dis = myArr[i] - myArr[i - 1];
    }
    if(M >= C) {
        printf("%d\n", C);
        return 0;
    }
    if (1 == M) {
        printf("%d\n", myArr[C - 1] - myArr[0] + 1);
        return 0;
    }
    sort(node, node + (C - 1), Cmp);
    for (int i = 0; i < (M - 1); ++i) {
        myVec.push_back(node[i].Pos);
    }
    sort(myVec.begin(), myVec.end());
    Solve();
    myVec.clear();
    return 0;
}

 

Prime Cryptarithm: 穷举即可。。。

 

/*
ID: Jming
PROG: crypt1
LANG: C++
*/

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <functional>
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <queue>
#include <map>
using namespace std;
#define eps 1e-8
int myArr[15];
int N;

bool myJudge(int x) {
    while (x) {
        int tmp1 = x % 10;
        int i;
        for (i = 0; i < N; ++i) {
            if (tmp1 == myArr[i]) {
                break;
            }
        }
        if (i == N) {
            return false;
        }
        x /= 10;
    }
    return true;
}

void Solve() {
    int ans = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            for (int k = 0; k < N; ++k) {
                int mydata = myArr[i] * 100 + myArr[j] * 10 + myArr[k];

                for (int m = 0; m < N; ++m) {
                    int data1 = mydata * myArr[m];
                    if (!myJudge(data1)) continue;
                    if (data1 >= 1000) continue;

                    for (int n = 0; n < N; ++n) {
                        int data2 = mydata * myArr[n];
                        if (!myJudge(data2)) continue;
                        if (data2 >= 1000) continue;
                        int myMul = data1 + data2 * 10;
                        if (!myJudge(myMul)) continue;
                        if (myMul >= 10000) continue;
                        ++ans;
                    }
                }
            }
        }
    }
    printf("%d\n", ans);
}

int main()
{
    freopen("crypt1.in", "r", stdin);
    freopen("crypt1.out", "w", stdout);
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf("%d", &myArr[i]);
    }
    Solve();
    return 0;
}

 

Combination Lock：
思路：
（1）根据 N 可以求出：
         1）农夫约翰的号码组合所能产生的不同的开锁号码组合的数目 S1；
         2）预设号码组合所能产生的不同的开锁号码组合的数目 S2。
（2）再求出以上1）和2）相同的号码个数 S3。
（3）推出答案： S1 + S2 - S3

注意： 锁上标号为 N 的号码在程序中用 0 表示

 

/*
ID: Jming
PROG: combo
LANG: C++
*/

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <functional>
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <queue>
#include <map>
using namespace std;
#define eps 1e-8
int N, Sum;
vector<int> arr0[3], arr1[3];

int Ini(vector<int> arr[3]) {
    int cnt = 1;
    int tmp;
    for (int i = 0; i < 3; ++i) {
        scanf("%d", &tmp);
        int pos = 0;
        for (int j = -2; j <= 2; ++j) {
            int mytmp = (tmp + j + N) % N;   
            if (find(arr[i].begin(), arr[i].end(), mytmp) == arr[i].end()) {
                arr[i].push_back(mytmp);
            }
        }
        cnt *= arr[i].size();
    }
    return cnt;
}

void Solve() {
    int mycount = 1;
    for (int i = 0; i < 3; ++i) {
        int tmp = 0;
        for (int j = 0; j < arr0[i].size(); ++j) {
            if (find(arr1[i].begin(), arr1[i].end(), arr0[i][j]) != arr1[i].end()) {
                ++tmp;
            }
        }
        mycount *= tmp;
    }
    printf("%d\n", Sum - mycount);
}

int main()
{
    freopen("combo.in", "r", stdin);
    freopen("combo.out", "w", stdout);
    scanf("%d", &N); 
    Sum = 0;
    Sum += Ini(arr0);
    Sum += Ini(arr1);
    Solve();
    return 0;
}

 

Wormholes:

/*
此题参考了正解。
关键：
  （1）枚举出所有两两匹配的情况。
    eg: 1 2 3 4 
      1）1-2 3-4
      2）1-3 2-4
      3）1-4 2-3
      所以共三种情况。
    解决办法：搜索（题目样例的搜索过程：参考示意图Wormholes.png）
  （2）判断匹配后的情况，是否会出现死循环。

*/
/*
ID: Jming
PROG: wormhole
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
const int MAX_N = 15;
int N;
int Pair[MAX_N];
int nextNd[MAX_N];

typedef struct Node {
  int x;
  int y;
} Node;

vector<Node> wormhole;

// 判断是否有死循环
bool isCycle() {
  for (int i = 0; i < N; ++i) {
    // 枚举每一个点作为出发点
    int pos = i;
    for (int j = 0; j < N; ++j) {
      if (pos == -1 || Pair[pos] == -1) continue;
      pos = nextNd[Pair[pos]];
    }
    if (pos != -1) return true;
  }
  return false;
}

// 枚举所有情况
int Solve() {
  int i = 0;
  int ans = 0;
  // 找到第一个尚未匹配的点
  for (; i < N; ++i) {
    if (Pair[i] == -1) break;
  }
  // 所有点都有了匹配的点？
  if (i == N) {
    if (isCycle()) return 1;
    else return 0;
  }
  // 枚举所有可能与 i 匹配的点 nd
  for (int nd = i + 1; nd < N; ++nd) {
    if (Pair[nd] == -1) {
      // 匹配点i 和 点nd，继续匹配
      Pair[i] = nd;
      Pair[nd] = i;
      ans += Solve();
      // 释放，枚举其他情况
      Pair[nd] = -1;
      Pair[i] = -1;
    }
  }
  return ans;
}

int main() {
  ifstream fin("wormhole.in");
  ofstream fout("wormhole.out");
  fin >> N;
  Node ndTmp;
  for (int i = 0; i < N; ++i) {
    fin >> ndTmp.x >> ndTmp.y;
    wormhole.push_back(ndTmp);
  }
  fin.close();
  int xxx = sizeof(nextNd);
  fill(nextNd, nextNd + MAX_N, -1);
  fill(Pair, Pair + MAX_N, -1);
  // 将(每个点)和(其右边最近的点)对应起来,保存于nextNd[]
  // 用于判断是否陷入死循环
  for (int i = 0; i < N; ++i) {
    for (int j = 0; j < N; ++j) {
      if (wormhole[i].y == wormhole[j].y && wormhole[i].x < wormhole[j].x) {
        if ((nextNd[i] == -1) ||
          (wormhole[j].x - wormhole[i].x < wormhole[nextNd[i]].x - wormhole[i].x)) {
          nextNd[i] = j;
        }
      }
    }
  }
  fout << Solve() << endl;
  fout.close();
  return 0;
}

Wormholes.png

Ski Course Design:

/*
需要注意：
change the height of a hill only once （一座山的高度只能改变一次）

（根据答案进行了优化） 
解法：枚举所有满足条件的高度区间
(0, 17), (1, 18), (2, 19), ..., (83, 100)
计算出使测试数据满足各个区间的花费，最小的即答案。
时间复杂度：O(M*N) 100*1000 = 10^5
*/
/*
ID: Jming
PROG: skidesign
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define MAX_N 1005

int hill[MAX_N];
int N;

int Solve() {
    int ans = INF;
    for (int lowest = 0; lowest <= 83; ++lowest) {
        int cost = 0, x;
        for (int i = 0; i < N; ++i) {
            if (hill[i] < lowest) {
                x = lowest - hill[i];
            }
            else {
                if (hill[i] > lowest + 17) {
                    x = hill[i] - (lowest + 17);
                }
                else {
                    x = 0;
                }
            }
            cost += x*x;
        }
        ans = min(ans, cost);
    }
    //cout << ans << endl;
    return ans;
}

int main() {
    ifstream fin("skidesign.in");
    ofstream fout("skidesign.out");

    fin >> N;
    for (int i = 0; i < N; ++i) {
        fin >> hill[i];
    }
    fout << Solve() << endl;

    fin.close();
    fout.close();
    return 0;
}