ccf-csp 2014冬季真题题解

---

1. 门禁系统
   问题描述
   　　涛涛最近要负责图书馆的管理工作，需要记录下每天读者的到访情况。每位读者有一个编号，每条记录用读者的编号来表示。给出读者的来访记录，请问每一条记录中的读者是第几次出现。
   输入格式
   　　输入的第一行包含一个整数n，表示涛涛的记录条数。
   　　第二行包含n个整数，依次表示涛涛的记录中每位读者的编号。
   输出格式
   　　输出一行，包含n个整数，由空格分隔，依次表示每条记录中的读者编号是第几次出现。
   样例输入
   5
   1 2 1 1 3
   样例输出
   1 1 2 3 1
   评测用例规模与约定
   　　1≤n≤1,000，读者的编号为不超过n的正整数。

代码：

#include 

using namespace std;

const int MAXN = 1010;
int arr[MAXN];

int main(){
    int n, a;

    cin >> n;
    while(n --){
        cin >> a;
        cout << ++ arr[a] << " ";
    }
    return 0;
}

---

2. Z字形扫描
   问题描述
   　　在图像编码的算法中，需要将一个给定的方形矩阵进行Z字形扫描(Zigzag Scan)。给定一个n×n的矩阵，Z字形扫描的过程如下图所示：
   
   　　对于下面的4×4的矩阵，
   　　1 5 3 9
   　　3 7 5 6
   　　9 4 6 4
   　　7 3 1 3
   　　对其进行Z字形扫描后得到长度为16的序列：
   　　1 5 3 9 7 3 9 5 4 7 3 6 6 4 1 3
   　　请实现一个Z字形扫描的程序，给定一个n×n的矩阵，输出对这个矩阵进行Z字形扫描的结果。
   输入格式
   　　输入的第一行包含一个整数n，表示矩阵的大小。
   　　输入的第二行到第n+1行每行包含n个正整数，由空格分隔，表示给定的矩阵。
   输出格式
   　　输出一行，包含n×n个整数，由空格分隔，表示输入的矩阵经过Z字形扫描后的结果。
   样例输入
   4
   1 5 3 9
   3 7 5 6
   9 4 6 4
   7 3 1 3
   样例输出
   1 5 3 9 7 3 9 5 4 7 3 6 6 4 1 3
   评测用例规模与约定
   　　1≤n≤500，矩阵元素为不超过1000的正整数。
   题解：
     稍复杂的模拟题，注意到矩阵同一次对角线上的横纵下标和是一样的，下标和的范围在 [0 , 2 * n - 1) ；此外扫描的顺序是蛇形的，所以设置一个bool 标记，为1 代表从右上向左下扫描，为 0 代表从左下向右上扫描；只有当我们对角线上的元素在矩阵内才输出，否则跳过。

代码：

#include 

using namespace std;

const int MAXN = 510;
int g[MAXN][MAXN], cnt = 1;

int main(){
    int n;
    bool op = false;

    cin >> n;
    for(int i = 0; i < n; i ++)
        for(int j = 0; j < n; j ++)
            cin >> g[i][j];
	//遍历对角线，下标和为 [0 , 2*n - 1)
    for(int i = 0; i < 2 * n - 1; i ++){
        int r, c;
        //从右上到左下扫描，首位置在第0行第i列
        if(op)
            r = 0, c = i;
        //从左下到右上扫描，首位置在第0列第i行
        else
            r = i, c = 0;
        //移动i次，这样子整个对角线都遍历了，不过有些坐标是在矩阵之外的，需要跳过
        for(int j = 0; j <= i; j ++){
        	//在矩阵内才输出
            if(r >= 0 && c >= 0 && r < n && c < n)
                cout << g[r][c] << " ";
            //从右上到左下，扫描时行 + 1 列 - 1
            if(op)
                r += 1, c -= 1;
            //从左下到右上，扫描时行 - 1 列 + 1
            else
                r -= 1, c += 1;
        }
        //蛇形扫描
        op = !op;
    }
    return 0;
}

---

3. 集合竞价
   问题描述
   　　某股票交易所请你编写一个程序，根据开盘前客户提交的订单来确定某特定股票的开盘价和开盘成交量。
   　　该程序的输入由很多行构成，每一行为一条记录，记录可能有以下几种：
   　　1. buy p s 表示一个购买股票的买单，每手出价为p，购买股数为s。
   　　2. sell p s 表示一个出售股票的卖单，每手出价为p，出售股数为s。
   　　3. cancel i表示撤销第i行的记录。
   　　如果开盘价为p0，则系统可以将所有出价至少为p0的买单和所有出价至多为p0的卖单进行匹配。因此，此时的开盘成交量为出价至少为p0的买单的总股数和所有出价至多为p0的卖单的总股数之间的较小值。
   　　你的程序需要确定一个开盘价，使得开盘成交量尽可能地大。如果有多个符合条件的开盘价，你的程序应当输出最高的那一个。
   输入格式
   　　输入数据有任意多行，每一行是一条记录。保证输入合法。股数为不超过108的正整数，出价为精确到恰好小数点后两位的正实数，且不超过10000.00。
   输出格式
   　　你需要输出一行，包含两个数，以一个空格分隔。第一个数是开盘价，第二个是此开盘价下的成交量。开盘价需要精确到小数点后恰好两位。
   样例输入
   buy 9.25 100
   buy 8.88 175
   sell 9.00 1000
   buy 9.00 400
   sell 8.92 400
   cancel 1
   buy 100.00 50
   样例输出
   9.00 450
   评测用例规模与约定
   　　对于100%的数据，输入的行数不超过5000。
   题解：
     简单的陈述题意，就是找到一个价格，要求低于等于价格的商品数量和 与 高于等于价格的商品数量和 两者之间的最小值最大。利用价格的单调性一次遍历就能得到答案。

代码：

#include 
#include 
#include 

using namespace std;
//p为价格 op为1是buy 为0是sell   num为数量
struct node{
    double p;
    int op, num;
    //首先先按照价格从小到大排序，如果相等再按照先sell再bug排序（为了最优解，先考虑sell）
    bool operator < (const node& t) const {
        if(abs(p - t.p) > 1e-6)
            return p < t.p;
        else
            return op < t.op;
    }
};
const int MAXN = 5010;
node arr[MAXN], g[MAXN];

int main(){
    int a, n = 1, j = 1;
    long long ans = 0, sum1 = 0, sum2 = 0;
    double t = 0;
    string s;

    while(cin >> s){
        if(s == "buy")
            cin >> arr[n].p >> arr[n].num, arr[n].op = 1;
        else if(s == "sell")
            cin >> arr[n].p >> arr[n].num, arr[n].op = 0;
        else
            cin >> a, arr[a].num = 0, arr[n].num = 0;
        n ++;
    }

    for(int i = 1; i < n; i ++){
    	//去除那些要删除的数据
        if(arr[i].num == 0)
            continue;
        g[j ++] = arr[i];
        if(arr[i].op)
        	//首先统计当价格为无穷小时，高于价格的商品数量
            sum1 += arr[i].num;
    }
    //按照价格从小到大排序
    sort(g + 1, g + j);
    for(int i = 1; i < j; i ++){
    	//当前价格是g[i].p，低于等于g[i].p数量要增加
        if(!g[i].op){
            sum2 += g[i].num;
        }
        long long s = min(sum1, sum2);
        if(s >= ans){
            ans = s;
            t = g[i].p;
        }
        //和上面一个if分开的原因是为了开盘价正好取到g[i].p的时候，题目说明开盘价可以和低价 高价相等
        //当前价格是g[i].p，在之后价格会变大，所以高于等于g[i].p数量会减少
        if(g[i].op)
            sum1 -= g[i].num;
    }
    printf("%.2lf %lld", t, ans);
    return 0;
}

---

4. 最优灌溉
   问题描述
   　　雷雷承包了很多片麦田，为了灌溉这些麦田，雷雷在第一个麦田挖了一口很深的水井，所有的麦田都从这口井来引水灌溉。
   　　为了灌溉，雷雷需要建立一些水渠，以连接水井和麦田，雷雷也可以利用部分麦田作为“中转站”，利用水渠连接不同的麦田，这样只要一片麦田能被灌溉，则与其连接的麦田也能被灌溉。
   　　现在雷雷知道哪些麦田之间可以建设水渠和建设每个水渠所需要的费用（注意不是所有麦田之间都可以建立水渠）。请问灌溉所有麦田最少需要多少费用来修建水渠。
   输入格式
   　　输入的第一行包含两个正整数n, m，分别表示麦田的片数和雷雷可以建立的水渠的数量。麦田使用1, 2, 3, ……依次标号。
   　　接下来m行，每行包含三个整数ai, bi, ci，表示第ai片麦田与第bi片麦田之间可以建立一条水渠，所需要的费用为ci。
   输出格式
   　　输出一行，包含一个整数，表示灌溉所有麦田所需要的最小费用。
   样例输入
   4 4
   1 2 1
   2 3 4
   2 4 2
   3 4 3
   样例输出
   6
   样例说明
   　　建立以下三条水渠：麦田1与麦田2、麦田2与麦田4、麦田4与麦田3。
   评测用例规模与约定
   　　前20%的评测用例满足：n≤5。
   　　前40%的评测用例满足：n≤20。
   　　前60%的评测用例满足：n≤100。
   　　所有评测用例都满足：1≤n≤1000，1≤m≤100,000，1≤ci≤10,000。
   题解：
     最小生成树裸题，Kruskal 和 Prim算法都可以，前者更好写一些。

代码：

#include 
#include 

using namespace std;

const int MAXN = 100010;
struct node{
    int a, b, c;
    bool operator < (const node &t) const {
        return c < t.c;
    }
};
node arr[MAXN];
int pre[MAXN];

int find(int a){
    return a == pre[a] ? a : pre[a] = find(pre[a]);
}

int main(){
    int n, m, cnt = 0, pos = 0, ans = 0;

    cin >> n >> m;
    for(int i = 1; i <= n; i ++)
        pre[i] = i;
    for(int i = 0; i < m; i ++){
        cin >> arr[i].a >> arr[i].b >> arr[i].c;
    }
    sort(arr, arr + m);
    while(cnt < n - 1){
        int a = find(arr[pos].a);
        int b = find(arr[pos].b);
        if(a != b){
            pre[a] = b;
            ans += arr[pos].c;
            ++ cnt;
        }
        ++ pos;
    }
    cout << ans << endl;
    return 0;
}

---

5. 货物调度
   问题描述
   　　某公司要处理一个周期性的物流问题。
   　　有n个城市，第i个城市在每周的第j(1≤j≤7) 天会生产aij吨某种货物，同时需要消耗bij吨该种货物。已知每周的产量等于消耗量（即a_ij之和等于b_ij之和）。
   　　城市之间有m条道路，第k条道路连接了城市s_k和t_k。一条道路上运输1吨货物有一个固定的成本ck。道路都可以双向使用。每天运输的货物量没有限制。城市之间的距离并不远，货物可以从任意一个城市运输到任意另一个城市并且在当天到达。
   　　货物如果在当天没有被消耗掉，就需要存放在仓库里过夜。第i个城市的仓库容量为vi，存放1 吨货物过一夜所需的成本是wi。
   　　请你计算该公司如果每周循环性地按照一个固定的流程调度货物的话，该公司在最优方案下每周需要为货物的运输和存储消耗多少成本。
   输入格式
   　　输入的第一行有两个正整数n和m，即城市的个数和道路的条数。
   　　接下来有n行，每行包含16个整数，用以描述第i个城市的相关数据。其中第i行包含的数为a_i1, a_i2, a_i3, a_i4, a_i5, a_i6, a_i7, b_i1, b_i2, b_i3, b_i4, b_i5, b_i6, b_i7, v_i, w_i。
   　　接下来有m行，每行包含3个整数，用以描述一条道路的相关数据。其中第k行包含的数为sk, tk和ck。
   　　输入数据中城市的编号均为1到n之间。输入数据的每行的行首行尾均保证没有空格，两个数之间恰好被一个空格隔开。
   输出格式
   　　你只需要输出一个数，即最优方案下每周的支出。
   样例输入
   3 3
   0 0 0 0 5 0 0 0 0 0 0 0 0 0 2 4
   0 0 0 0 0 0 0 2 0 0 0 0 0 0 2 1
   0 0 0 0 0 0 0 0 0 3 0 0 0 0 2 5
   1 2 1
   1 3 5
   2 3 1
   样例输出
   67
   样例说明
   　　城市1 每周五生产5 吨货物，把其中2 吨运到存储费用低廉的城市2 存储，把1 吨运到城市3 存储，剩下的2 吨留在城市1。
   　　在次周一的时候城市2 会消耗掉存放在那里的2 吨货物。为了节约存储成本，将囤放在城市1 的货物运到城市2 存放。周三再将所有货物运到城市3 以满足该城市的需求。
   　　在此方案下，每周的运输成本为8，每周的存储成本为59，因此每周的总支出为67。
   评测用例规模与约定
   　　对于100%的数据，1≤n≤100，1≤m≤500，0≤a_ij,b_ij,v_i≤100，1≤w_i,c_k≤100。
   题解：
     涉及到网络流算法，下面是别人的代码，共同学习。

代码：

#include 
#include 
#include 

using namespace std;

const int N = 710, M = (N * 3 + 500 * 7 * 2) * 2 + 10, INF = 0x3f3f3f3f;

int n, m, S, T;
int h[N], e[M], f[M], w[M], ne[M], idx;
int q[N], d[N], pre[N], incf[N];
bool st[N];

int get(int a, int b)
{
    if (b == 8) b = 1;
    return (a - 1) * 7 + b;
}

void add(int a, int b, int c, int d)
{
    e[idx] = b, f[idx] = c, w[idx] = d, ne[idx] = h[a], h[a] = idx ++ ;
    e[idx] = a, f[idx] = 0, w[idx] = -d, ne[idx] = h[b], h[b] = idx ++ ;
}

bool spfa()
{
    int hh = 0, tt = 1;
    memset(d, 0x3f, sizeof d);
    memset(incf, 0, sizeof incf);
    q[0] = S, d[S] = 0, incf[S] = INF;
    while (hh != tt)
    {
        int t = q[hh ++ ];
        if (hh == N) hh = 0;
        st[t] = false;

        for (int i = h[t]; ~i; i = ne[i])
        {
            int ver = e[i];
            if (f[i] && d[ver] > d[t] + w[i])
            {
                d[ver] = d[t] + w[i];
                pre[ver] = i;
                incf[ver] = min(incf[t], f[i]);
                if (!st[ver])
                {
                    q[tt ++ ] = ver;
                    if (tt == N) tt = 0;
                    st[ver] = true;
                }
            }
        }
    }
    return incf[T] > 0;
}

void EK(int& flow, int& cost)
{
    flow = cost = 0;
    while (spfa())
    {
        int t = incf[T];
        flow += t, cost += t * d[T];
        for (int i = T; i != S; i = e[pre[i] ^ 1])
        {
            f[pre[i]] -= t;
            f[pre[i] ^ 1] += t;
        }
    }
}

int main()
{
    cin >> n >> m;
    S = 0, T = n * 7 + 1;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i ++ )
    {
        int c, d;
        for (int j = 1; j <= 7; j ++ )
        {
            cin >> c;
            add(S, get(i, j), c, 0);
        }
        for (int j = 1; j <= 7; j ++ )
        {
            cin >> c;
            add(get(i, j), T, c, 0);
        }
        cin >> c >> d;
        for (int j = 1; j <= 7; j ++ )
            add(get(i, j), get(i, j + 1), c, d);
    }
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        for (int i = 1; i <= 7; i ++ )
        {
            add(get(a, i), get(b, i), INF, c);
            add(get(b, i), get(a, i), INF, c);
        }
    }
    int flow, cost;
    EK(flow, cost);
    cout << cost << endl;
    return 0;
}