新浪的 spamer 越来越多，很早就想搬到独立的 wordpress 上去，但是一直没顾上。只好先在sina这里凑合着了。

Description

Input

Output

Sample Input

 3 4 5 10
 1 2
 0

Sample Output

 46
 2 4 10
 4
 1 2

Source

Asia Guangzhou 2003

Solution

很久不更新了，写个水水的解题报告充数。。。这是最近做的算法习题，网上看到这题的题解都是二分+贪心的，这里提供一个dp解法。

理解题意的时候有一点需要特别注意：题目所描述的整个过程是“并行”的。所以所有人都到达各自楼层的用时只与最晚到达的人有关。

首先，由于去各楼层乘客的具体数目对结果没有影响，为表述方便，我们假设每个目标楼层只有一个人要去，并且把各个目标楼层与要去该楼层的那个乘客对应。下面在说“电梯里还剩i个人”的时候，就是在说“电梯里的乘客还要去i个楼层”。

粗略的阶段划分和状态表示还是很简单的。

电梯从第1层开始层层上升，每层都看做一个阶段，任意时刻的状态都可以由“电梯在几楼”和“电梯上都有谁”这两个参数唯一确定。初始状态就是“电梯在1楼”和“所有人都在电梯上”。

在每个阶段需要做出决策，选择让电梯上的哪些人下来自己走（如果没人下来就表示电梯在这层不停）。每个决策发生后，原来电梯里的人被分成两拨：一拨留在电梯上继续上升，另一拨离开电梯开始爬楼锻炼身体。要求某个状态下电梯里的所有人到达各自楼层所需的最短时间，只需要找到一个最优的决策，使得上述两拨人中最晚到达的人尽早到达。

即，若设决策后留在电梯里的人全部到达各自楼层需要时间 T1，离开电梯的人全部到达需要时间 T2，则要求的就是 min{ max(T1, T2) }。其中 T1 可由“当前层数+1”和“决策后剩下的人”确定的状态得到；T2 则是下电梯的人中走的最远的那位所花的时间。

按照上述想法很容易列出转移方程。但是“电梯上都有谁”这一参数有 2^n 种取值，整个算法的复杂度因此能到达令人发指的O(m*2^2n)，对于m=31，n=30的数据规模这是不可接受的。

我们需要设法减少需要考虑的状态数目。下面给出两个引理：

1. 电梯决定停在第k层时：要去 1..k 层的人应选择在这时下电梯，这样一定可以得到当前决策下的一个最优解。如图：

2. 电梯在第k层时，若要去 k+r 层的人选择在这时下电梯，则：要去k+1..k+r-1层的人也应选择在此时下电梯，这样一定可以得到当前决策下的一个最优解。如图：

以上两点很容易证明。由这两点可以得到一个很简单但足以解决问题的结论：

无论电梯停在哪一层，若要去第 k 层的人选择在这时下电梯，则：所有要去低于k层（第1..k-1层）的人也应选择在此时下电梯，这样一定可以得到当前决策下的一个最优解。如图：

也就是说，如果把初始时的 n 名乘客按照各自要去的层数从高到低（注意此顺序与输入相反）排列，并依此编号为第 1、2、3…n 个人，第 i 个人要去第 f[i] 层（f[1]>f[2]>…>f[n]），那么可以认为任意时刻电梯里乘客的编号都是 1, 2,..,x 这样一个连续序列。也就是说，对于电梯里的人我们只需要考虑编号为 1, 2, 3 或 1, 2, 3, 4, 5 这样连续排列的情况，而无需考虑 1, 2, 4（缺3）或2, 3, 4（缺1）这样的情况。

这样一来，每个状态都能由两个数[i,j]来表示：电梯在第i层，电梯里有j个人，即要去楼层最高的第1,2,..,j个人。

下面给出转移方程：

f[i,j]表示电梯在第i层，电梯上有要去楼层最高的j个人时，电梯上的人全部到达各自楼层所需的最短时间

f[i,j] = min{ max(t1, t2) } (0<=k<=j)

t1 = f[i+1, k] + 电梯停留时间 + 电梯上升一层所用时间

t2 = max{ |d[l] – i| * 人爬一层楼所用时间 } ( k+1<=l<=j )

边界条件、最优解的构造方法以及其它细节问题不再赘述，详见代码。复杂度O(m*n^2)。代码中其实还有优化的空间，但已经是0ms过的，没必要了。

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

#include <cstring>
using std::memset;

#include <algorithm>
using std::max;

#include <cmath>
using std::abs;

#include <limits>
using std::numeric_limits;

#include <vector>
using std::vector;

const int maxN = 30, maxF = 31;
const int ve = 4, st = 10, vw = 20; // 电梯上一层所需时间；电梯停一层所需时间；人走一层所需时间

int n, f[maxN + 1];

bool input()
{
    cin >> n;
    if (n==0) return false;

    // 注意：f[1..n]中楼层数从高到底排列
    for (int i = n; i>=1; --i)
        cin >> f[i];

    return true;
}

int dp[maxF + 1][maxN + 1], nextJ[maxF + 1][maxN + 1];

// 现在电梯在第currF层，第L到第R人离开电梯
// 函数返回这些离开电梯的人中最晚到达目的楼层所需的时间
int tLeave(int currF, int l, int r)
{
    if (l>r)  return 0;
    // 仅需考虑两端
    return max(abs(currF-f[l]), abs(currF-f[r])) * vw;
}

// 现在电梯在第i层，电梯里本来有j个人，在要下电梯的人离开后还剩jj个人
// 函数返回这些留在电梯里的人中最晚到达目的楼层所需的时间
int tStay(int i, int j, int jj)
{
    // 没人下电梯
    if (j==jj)
        return dp[i+1][jj] + ve;
    // 所有人都离开电梯
    else if (jj==0)
        return 0;
    // 第1层不计算电梯停留时间
    else if (i==1)
        return dp[i+1][jj] + ve;
    //普通情况
    else
        return dp[i+1][jj] + ve + st;
}

void calculate()
{
    // 边界：电梯在顶楼时所有人都必须下电梯
    int topFloor = f[1];
    for (int j = 1; j<=n; ++j)
        dp[topFloor][j] = tLeave(topFloor,1,j);

    for (int i = topFloor - 1; i>=1; --i)
        for (int j = 1; j<=n; ++j)
        {
            dp[i][j] = numeric_limits<int>::max();
            for (int jj = 0; jj <= j; ++jj)
            {
                // 取离开电梯的人和留下的人中的最晚到达者
                int tmp = max(tStay(i,j,jj),tLeave(i,jj+1,j));
                if (dp[i][j] > tmp)
                {
                    dp[i][j] = tmp;
                    nextJ[i][j] = jj;
                }
            }
        }
    cout << dp[1][n] << endl;
}

void rebuildSolution()
{
    vector<int> stops;
    int j = nextJ[1][n], topFloor = f[1];
    for (int i = 2; i<=topFloor; ++i)
        if (nextJ[i][j]!=j)
        {
            stops.push_back(i);
            j = nextJ[i][j];
            if (j==0) break;
        }

    cout << stops.size();
    for (int i = 0; i!=stops.size(); ++i)
        cout << ' ' << stops[i];
    cout << endl;
}

void solve()
{
    memset(dp,0,sizeof(dp));
    memset(nextJ,0,sizeof(nextJ));
    calculate();
    rebuildSolution();
}

int main()
{
    while (input())
        solve();
}

可能你对下面的文章也感兴趣：

1. [NOI97]积木游戏(Game)
2. [NOI99]棋盘分割(Chessboard Division)
3. [NOIP05]过河

窗口（超级版）

时间限制:5000 ms 内存限制:65535 KB

描述

有一串整数在排队……

有N个整数，你有一个可以框住M个连续段整数的木框，现在你想知道，对于这个队列中任意的连续M个整数，最大和最小的整数是哪个？

例：(M大小的窗口向右滑动)

1 2 3 2 1   M=2
1 2    MAX 2  MIN 1
2 3    MAX 3  MIN 2
3 2    MAX 3  MIN 2
2 1    MAX 2  MIN 1

最后需要输出的是两行：

1 2 2 1
2 3 3 2

输入

第一行包含一个整数T，表示有T组测试数据；
以下每组测试数据格式：
第一行包含2个整数N,M表示有N个整数在排队，取连续M个整数。
第二行包含N个整数。
其中N不大于1,000,000，M不大于N。

输出

按照题目描述格式输出结果，第一行为MIN，第二行为MAX。

样例输入

1
5 2
1 2 3 2 1

样例输出

1 2 2 1
2 3 3 2

提示

注意数据规模！

问题来源

软件学院07级数据结构第二次测试

题解

很久不考虑算法问题了的说……当然也好久不写解题报告了。上面这题让我体会到久违了的思考的乐趣（i.e.我废掉好久了>_<）

最显然的解法是利用平衡树始终保持木框内M个数的有序状态，大体是O(NlogM)的复杂度。这个不用多说。

问题是：能否找到O(N)的解法？在读下去之前你可以好好想想。

我纠结了好久，终于……也没想出来- – 尽管想出很多优化，终究还是不能达到要求。网上搜了下，看到 CS大牛csdn 上有人给出了一个解法（你也可以在读完全文后再回头看这一段）：

是可以到o(n);

编程之美上有一个类似的问题:”队列中取最大值操作问题”;
实际上窗口移动就相当于对队列做了一次出队与入队操作，所以lz这道题可以套用该解法；

书上是使用两个栈来模拟队列，假设为分别A,B;
1)当入队的时候，push A；
2)当出队的时候,
a)若B非空,pop B,
b)若B为空，则先将A中的元素依次pop并push到B,再pop B;
这样,就使用两个栈达到了队列的功能;

同时,对于单个栈，由于pop,push都是在栈顶进行的，所以每个栈都可以方便地维护自己的最
大值与最小值在栈内的索引；
以最大值为例；
用max_idx保存栈内最大值的索引;
另使用一个跟栈的最大长度一样的数组idx,idx[i]表示栈的索引范围在0到i-1的元素中的最
大值的索引为idx[i];
1) 当push的时候，比较栈顶元素与栈的已保存的最大值，
a) 若栈顶元素大于已保存的最大值,那么idx[top]=max_idx,max_idx=top;
b) 若栈顶元素不大于已保存的最大值,那么idx[top]=max_idx(书上是idx[top]=-1);
2) 当pop的时候，max_idx=idx[top](书上是先比较top与max_idx，若top==max_idx,则
max_idx=idx[top]);

具体到这个题目；
可以使用两个长度为m的栈来模拟窗口；
1)将前m个元素依次push到栈A;
2)移动窗口就相当于分别进行pop B　与　push A操作;
3) 窗口的最大值==max[A.items[A.max_idx]),B.items[B.max_idx])]；

由于每个元素最多进入两栈各一次；
所以总的复杂度是o(n)的;

这个解法的确可行，但描述仍不直观。为什么两个栈暧昧地眉来眼去一番，就在O(N)时间内把问题解决了呢？褪去实现上的种种细节，从更高的角度观察这个算法，它的思路是怎么样的呢？

和冬冬讨论了半天，似乎找到了一个比较靠近此算法根本动机的理解方向。如下：

一、简化

此问题中，框的左端和右端同时在向右移动。这时，要在任意时刻用O(1)的时间获得框内最小值（最大值同理，故仅以最小值为例）并不容易。但是，如果假设这个框是可伸缩的，将其一端固定，仅移动另外一端，任意时刻能否在O(1)的时间内获得最小值呢？

稍加思考，就发现要找到这样的算法是很容易的（事实上在我最初考虑时，就是试图在这样一个算法的基础上进行优化的）。

假如这个框是左端固定，右端不断向右移动的（称之为左定右动框）。对于框内的每个数，有一个对应指针指向框内它左边（包括自身）所有数中最小者。这样，框内最小值就是框内最右端元素对应的指针所指向的元素。如在下图中，最小元素就是右端7对应指针所指向的元素6。

min = 6

当框的右端向右扩展时，可以通过递推获得新元素对应指针应指向的元素。以上图为例。加入2时，由7对应的指针可知原框中最小值为6，而6>2，所以新元素2对应的指针应指向自己。

min = 2

加入8时，由2的指针知原框中最小值为2，而2<8，所以新元素8对应指针应指向2的指针所指向的元素2。

min = 2

其余如法炮制。

min = 2

可见，在框左端固定、右端不断扩展时，任意时刻都能在常数时间内确定框内元素的最小值。（不仅如此，即使需要让右端向左收缩，也能在常数时间内，通过最右端元素指针获得得到收缩后框内所剩元素的最小值。） 整个过程演示如下（先扩张后收缩）：

演示中的收缩操作在当前问题中并无必要。演示出来是为了说明无论右端如何移动，只要左端不动，就可以在任意时刻立刻得到最小值。同时也是为了与下面一个演示保持一致。

如果一个框右端固定，左端收缩（称之为右定左动框），也可以在任意时刻花费常数时间获得框内的最小元素。过程和上面左右对称。具体地说，每个元素对应一个指针，指向框内它右边（包括自身）所有数中最小者。首先需要从右到左计算出各个元素对应的指针。这个过程类似于将框的左端由右向左扩展。计算完毕后就可以在收缩左端的过程中在常数时间内获得最小元素了。

演示如下（先扩张后收缩，可以看到完全和上面对称）：

对于当前问题，在“扩张”过程中并不需要求最小值，而仅仅需要计算出指针来为收缩过程作准备。这里在全过程中标注出最小值是为了说明任意时刻都有能力得到它，也为了与上一个演示保持一致。

上面拉拉杂杂说了一堆，只为了说明：如果框的一端固定，仅移动另外一端，则在此过程中可以仅花费常数时间获得框内的最小元素。针对左定右移、右定左移两种情况的算法是彼此对称的。

最后顺带提一点实现细节，希望不会影响你对整体的理解。上面所使用的指针也可以用索引号来代替，这里使用指针是为了显得更形象。事实上，不保存索引或指针而直接保存最小的“值”也是可行的，但是并不推荐。设想，如果每个元素不是数而是四五米长的字符串（>_<），偏序关系使用字符串长度的比较，那么如果不保存指针/索引而保存值，所带来的元素复制开销恐怕不是你想要的。

二、推广

怎样把上面只允许一端移动的解法推广到同时允许两端移动呢？

一种想法是，将以上二者合二为一。具体地说，将框内的数看成左右两部分，左边一部分看成右定左动的，右边一部分看成左定右动的。这样，在左边收缩、右边扩张的过程中，左右两部分都可以在常数时间内得到最小元素。取两个最小元素中更小者，即为整个框中的最小元素。

OK，这就是O(N)算法的基本思路了。回到原题目，下面看一个例子。

假设我们要处理的是这么一串数：

3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3

框的大小为5。

首先，把最先被框住的5个数看成被一个右定左动的框框住，这5个数右边看成是一个空的左定右动框。当然，首先需要计算出开始这5个元素对应的指针：

接下来，左边的右定左动框收缩，右边的左定右动框扩张。在此过程中，框在框中的M个元素的最小者可以在常数时间内获得。

到左边部分收缩至空时就没有办法继续收缩了。怎么继续这个过程呢？

解决方法是，将右端含有M个元素的左定右动框重新处理为右定左动框，并在右边再放上一个空左定右动框：

接下来继续这个过程就行了。下面是全过程的演示：

你可能会对每次将右边的左定右动框重新处理为左边的右定左动框（有点晕- -）时计算指针造成的额外开销存有疑虑。然而，每次重新计算时需要处理M个元素的指针，每隔M个元素才会进行一次这样的处理，N/M*M仍然为N，并不会升高复杂度的阶。换句话说，每个元素至多被重新计算两次指针，所以总体复杂度仍然为O(N)。

以上就是整个解法。

三、关于栈

我们可以把右定左动框看成是一个底在右顶在左的栈，左端向左扩张看成是向栈push元素，左端向右收缩看成是栈在pop元素。左定右动框亦然。前面提到，两种框上的操作是对称的；如果把它们都看成栈，则push和pop时的操作完全一致。这样就将两种框对称的操纵统一在了同一个数据结构上，使得实现起来更为简洁。

这就是对开始所引用那段算法描述的解释。

四、问题的扩展

更进一步，我们还可以使用类似的方法处理此问题的变种。如，对于一个队列，随意进行入队出队操作（相当于木框的宽度不再固定为M，其两端也不同时向右移动），求在任意时刻队列中的最小元素。或者，一个双端队列，在两端随意进行入队出队操作，求任意时刻队列中的最小元素。等等。

最后顺便一提，在搜索此题资料时发现这个问题似乎涉及到数据流的处理算法。这个方面我一无所知，没办法站在那样一个高度阐述，抱歉。

可能你对下面的文章也感兴趣：

1. [VIJOS 1014]旅行商简化版
2. [IOI2000国家队原创题] 艺术馆的火灾
3. [NOI 05]聪聪与可可

篝火晚会

(fire.pas/c/cpp)

【问题描述】
佳佳刚进高中，在军训的时候，由于佳佳吃苦耐劳，很快得到了教官的赏识，成为了“小教官”。在军训结束的那天晚上，佳佳被命令组织同学们进行篝火晚会。一共有n个同学，编号从1到n。一开始，同学们按照1，2，……，n的顺序坐成一圈，而实际上每个人都有两个最希望相邻的同学。如何下命令调整同学的次序，形成新的一个圈，使之符合同学们的意愿，成为摆在佳佳面前的一大难题。

佳佳可向同学们下达命令，每一个命令的形式如下：

(b1, b2,… bm -1, bm)

这里m的值是由佳佳决定的，每次命令m的值都可以不同。这个命令的作用是移动编号是b1，b2，…… bm –1，bm的这m个同学的位置。要求b1换到b2的位置上，b2换到b3的位置上，……，要求bm换到b1的位置上。

执行每个命令都需要一些代价。我们假定如果一个命令要移动m个人的位置，那么这个命令的代价就是m。我们需要佳佳用最少的总代价实现同学们的意愿，你能帮助佳佳吗？

【输入文件】
输入文件fire.in的第一行是一个整数n（3 <= n <= 50000），表示一共有n个同学。其后n行每行包括两个不同的正整数，以一个空格隔开，分别表示编号是1的同学最希望相邻的两个同学的编号，编号是2的同学最希望相邻的两个同学的编号，……，编号是n的同学最希望相邻的两个同学的编号。

【输出文件】
输出文件fire.out包括一行，这一行只包含一个整数，为最小的总代价。如果无论怎么调整都不能符合每个同学的愿望，则输出-1。

【样例输入】
4
3 4
4 3
1 2
1 2

【样例输出】
2

【数据规模】
对于30%的数据，n <= 1000；
对于全部的数据，n <= 50000。

【题解】

至此我就算做完了NOIP05提高组的全部四道题，发现除了第一题外其它题都不水，对于我这样的水平来说很值得一做。过河的状态压缩我想了好久；本题优化方法较过河简单，但也需要动动脑子；至于那个等价表达式则是典型的ws题：思想简单（特值法+用栈求表达式的值），但实现起来却比较繁琐，细节硕多，稍不留神就会出错，我前后一共提交了5次才AC（得到的分数分别是20、30、40、90、100）。还好这些题都是自己独立搞出来的。顺带一提，等价表达式取特值时并不像很多人说的要多个，一个足矣，当然不要取太特殊的，比如取a=1,-2,-3,0这样的就很容易被强数据阴掉，但要是取个a=-5.65742它不就没治了；同时B4数据中括号不匹配的情况。

当然这都是题外话，下面言归正传。

首先需要看到的是，虽然佳佳下达的命令形式很ws，但是在求总代价的时候却完全不需要管它。显然，在佳佳下达完一系列诡异的命令后，最后有几个人离开了原来的位置，这种情况下最小代价就是几（为什么？）。看清了这一点，问题就转化为：要使得所有人满意，最少需要让几个人离开原来的位置？

我们先考虑无解的情况。把每个人看成无向图中的节点，两人相邻则连一条边。当n个人以某种次序围坐成一个圈的时候，每个节点的度一定都是2。而这种状态一定是初始状态通过若干次次序调整能达到的，即一定有解。那么无解的情况就一定是，根据同学们的希望构图后有同学的度不为2。这样，我们只需要构图，然后看是否所有节点的度都为2就可以判断是否有解了。

如果有解，下面就需要计算最小代价了。对于我们构得的图，DFS(1)后一定得到唯一的一个序列。例如1,5,3,2,4。我们现在就需要比较它和初始状态1,2,3,4,5，看有几个人离开了原来的位置。但这个序列实际代表的是一个环，而且方向正反有两种（即1,3,5,2,4和4,2,5,3,1应该是等价的），我们就需要把初始序列正反分别“转”N次（即1,2,3,4,5; 5,1,2,3,4; 4,5,1,2,3; 3,4,5,1,2; 2,3,4,5,1 以及 5,4,3,2,1; 1,5,4,3,2; 2,1,5,4,3; 3,2,1,5,4; 4,3,2,1,5）和DFS得到的序列比较，看其中最少有几个位置上的人编号不相同，就得到了我们要求的最小代价。

DFS是O(N)的；旋转可以通过指针来实现，所以是O(1)的；每次比较是O(N)的，共进行2N次比较。因此总的复杂度是O(N^2)的。期望得分为30分（我没写过这方法哈）。

进行很多次旋转，每次都需要比较，这种方法实在太慢了，是整个算法的瓶颈。怎么改进呢？我们发现转来转去不管怎么转，任意两个人之间的相对位置关系在这过程中都不会变。于是想到做差。

1 5 3 2 4
- 1 2 3 4 5
————-
0 3 0 3 4  （如果差小于0则加上N=5）

这表示序列1,5,3,2,4不转动时1,3两个人在原来的位置上，转动3个位置后5和2两个人在原来的位置上，转动4个位置后只有4一个人会在原来的位置上。这就是说，1,5,3,2,4与1,2,3,4,5在旋转后最多有2个位置上的人编号相同，即最少有3个位置上的人编号不相同。同理：

1 5 3 2 4
- 5 4 3 2 1
————-
1 1 0 0 3  （如果差小于0则加上N=5）

1,5,3,2,4与5,4,3,2,1在旋转后最少有3个位置上的人编号不相同。

取其中的较小者（例子没举好，两个值相同了）为3，即最后要求的最小总代价为3。问题就算解决了。

算法流程总结如下：

1. 根据输入构图，要求每个节点度只能为2，否则无解；
2. dfs得到一个序列seq表示符合条件的环
3. （下标从1开始）
   令a[i]=seq[i]-i（若小于0则+N）
   a中最多有x个相等的值
   令b[i]=seq[i]-(N+1-i)（若小于0则+N）
   a中最多有y个相等的值
4. n-max(x,y)即为所求

改进后的算法复杂度为O(N)，实现起来很简单。期望得分为100。

#include <iostream>
#include <fstream>
#include <cassert>
using namespace std;
long N,seq[50001],p=1;
class{
	private:
		long nbr[50001][3];
		bool flag[50001];
		bool isnbr(long v1,long v2){
			for(int i=1;i<=nbr[v1][0];i++)
				if(nbr[v1][i]==v2)	return true;
			return false;
		}
	public:
		bool AddE(long v1,long v2){
			if(isnbr(v1,v2))	return true;
			else if(nbr[v1][0]==2||nbr[v2][0]==2)	return false;
			else{
				nbr[v1][++nbr[v1][0]]=v2;
				nbr[v2][++nbr[v2][0]]=v1;
				return true;
			}
		}
		void dfs(long i){
			assert(!flag[i]);
			flag[i]=true,seq[p++]=i;
			for(int j=1;j<=nbr[i][0];j++){
				if(!flag[nbr[i][j]]){
					dfs(nbr[i][j]);
					break;
				}
			}
		}
}G;
long solve(void){
	long cnt1[50001]={0},cnt2[50001]={0},ans=0;
	for(int i=1,a,b;i<=N;i++){
		a=seq[i]-i;
		if(a<0)	a+=N;
		b=seq[i]-(N+1-i);
		if(b<0)	b+=N;
		if(++cnt1[a]>ans)	ans=cnt1[a];
		if(++cnt2[b]>ans)	ans=cnt2[b];
	}
	return N-ans;
}
int main(){
	ifstream cin("fire.in");
	ofstream cout("fire.out");
	cin >> N;
	for(int i=1,nbr1,nbr2;i<=N;i++){
		cin >> nbr1 >> nbr2;
		if(!G.AddE(i,nbr1)||!G.AddE(i,nbr2)){
			cout << -1 << endl;
			return 0;
		}
	}
	G.dfs(1);
	cout << solve() << endl;
	return 0;
}

最后再给一个在vijos里看到的算法。我自己没有实现过，有兴趣的试试吧。

见过的最牛最简单的方法……

将此题转换为冒泡排序，记录下所有交换的次数和两数间的距离，加上就行了……—__—|||

具体是这样的，我们反向思维，本来是要求一个有序数列求出成为无序数列的代价，现在我们把无序数列（即目标数列）进行冒泡排序，然后……就是这样…… 看完之后，偶巨汗……

可能你对下面的文章也感兴趣：

1. [NOIP05]过河
2. [VIJOS 1006]晴天小猪历险记之 Hill
3. [VIJOS 1037]搭建双塔

过河

(river.pas/c/cpp)

【问题描述】

在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0，1，……，L（其中L是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。

题目给出独木桥的长度L，青蛙跳跃的距离范围S,T，桥上石子的位置。你的任务是确定青蛙要想过河，最少需要踩到的石子数。

【输入文件】

输入文件river.in的第一行有一个正整数L（1 <= L <=10^9），表示独木桥的长度。第二行有三个正整数S，T，M，分别表示青蛙一次跳跃的最小距离，最大距离，及桥上石子的个数，其中1 <= S <= T <= 10，1 <= M <= 100。第三行有M个不同的正整数分别表示这M个石子在数轴上的位置（数据保证桥的起点和终点处没有石子）。所有相邻的整数之间用一个空格隔开。

【输出文件】

输出文件river.out只包括一个整数，表示青蛙过河最少需要踩到的石子数。

【样例输入】

10

2 3 5

2 3 5 6 7

【样例输出】

2

【数据规模】

对于30%的数据，L <= 10000；

对于全部的数据，L <= 10^9。

【题解】

一看题，这无后效性和最优子结构也太明显了，随手就可以列出转移方程。令dp[i]表示处于i位置时，最少还要踩到几个石子（包括当前点）才能到达对岸。bridge[i]为点i处的石子个数（0或1）。则

当0≤i<L时：dp[i] = min{dp[i+j]} + bridge[i]   (S≤j≤T)

当i≥L时：dp[i]=0

问题的解即为dp[0]。

但是这样写完交上去最多只能得30分。直接硬搞，复杂度是O(L*(T-S))的，T-S最大为9，无关紧要，但是L的最大值则是令人发指的10^9（青蛙跳这么长距离不累死么 – -），不TLE……恐怕需要10年以后的CPU了。那怎么办呢？（思考过程也许比较繁琐，要结论请直接看倒数第5段）

数据范围往往是算法选择的最重要的提示。我们看到虽然L这么巨大，但是石子的总数却不超过100个。这说明什么？说明桥上必然有大段大段的无石子区间，而无石子区间的最大长度在极限情况下将接近10^9。即在跳跃中，青蛙经常会很郁闷地在巨长的无石子区间上跳啊跳啊，想踩个石子都踩不到。上面那个普通dp肯定会导致空白区间上大量的无必要决策而无谓耗费大量时间。要减少这种时间浪费，我们可以试图把大段的无石子区间等效转化为较短的无石子区间，从而使时间开销降至可承受范围。

首先考虑最简单的情况：S=T。这种情况下，这个诡异的青蛙只能跳固定的长度。而跳的起点是0位置，那么青蛙经过的就只有S（或者说T，一回事）的整数倍点。如果石子的位置为S的整数倍，那么青蛙就一定会踩到，否则一定踩不到。比如S=T=3，L=100，那么青蛙经过的点就为且仅为0，3，6，…，96，99。在21、27、33、66等处的石子就一定能踩到，而20、40、80、92等处的石子就踩不到。于是，当S=T时，我们只需要数位置为S整数倍的石子有几个就得到了答案，不需要进行上面说到的“等效转化”。

那如果S≠T呢？我们也从一个最简单的例子看起。假如S=5，T=6，青蛙从0位置开始跳，那么它可能到达的点是：

5，6，

10，11，12，

15，16，17，18，

20，21，22，23，24，

25，26，27，28，29，30，31，32，33，……

可以看到，这些点组成了一个个连续的区间，各相邻区间起点间的距离都是S=5，开始区间长度为2，然后长度变为3，4，然后完全连在一起，后面的位置都可达。如果桥上0~999都没有石子，1000处有一个石子，那么我们只关心青蛙是否选择跳到999，998，997，996，995，994这几个位置，因为青蛙在这段无石子区间上跳半天最后总会跳到这6个位置上，在无石子区间中不管怎么跳其实都无所谓。那么，我们完全可以无视25以后的数，把这段区间等效为0~25，以确保25以后所有位置都可达且有20~25这段连续区间来代替994~999这段等长的区间。这样，我们在这段无石子区间上的决策就大大减少了。

桥上的其他无石子区间是否可以如法炮制呢？答案是肯定的。对于以后任何一段长度大于25+6=31的无石子区间（这是采取“等效”措施的“门槛”），我们都可以把它的长度看成31。（25为什么要加上6呢？考虑一下，进入这段无石子区间后，青蛙开始往前跳的的起点，它可能不是区间本身的起点。）这样处理后，即使桥长度达到10^9，也可以在非常短的时间内出解。事实上，我们不仅可以把无石子区间长度等效为31，等效为36，121，500也都可以，只要长度比31大就行（当然“门槛”也要相应升高）。我们把这个等效区间的“最短”长度（本例中为31）称为“等效区间最短长度”。

下面推广。当S≠T时我们发现，在T不变的情况下，T-S越大（即S越小），等效区间最短长度越短。T-S不变的情况下，T越大，等效区间最短长度越长。那么对于题目给出的数据范围，S=9，T=10时（满足T-S最小且T最大）得到最大的“等效区间最短长度”为100。对于其他的S和T，我们不需要专门计算它们对应的等效区间最短长度，直接采用100这个值就可以了。

综上，若S=T，我们直接数位置能被S整除的石子个数；若S≠T，如果某无石子区间长度大于100，则等效为100，否则不变，然后再dp。

至于为什么有同学取比100小的数也AC了，我觉得（不一定对哈，没验证）应该是数据弱了。经实验，即使取20也可以AC，取10也才WA一个点。

对于等效区间最短长度的这番计算其实完全不必要。比赛时最好的方法是：取时间复杂度可接受的最大值……这样最省事。

上面可能做麻烦了，欢迎提供简明解法，谢谢。

最后说点题外话。这题我调了一晚上，郁闷死了。最后发现问题竟然是：石子位置没有按照升序排列，我却想当然这么处理了，结果一个点都过不去……

代码如下：

#include <iostream>
#include <fstream>
#include <bitset>
#include <cstdlib>
using namespace std;
unsigned long L_orig,L,S,T,M,pos[102],dp[12000],ans;
bitset<12000> bridge,flag;
long memo(long i){
	if(i>=L)	return 0;
	if(flag[i])	return dp[i];
	flag[i]=1,dp[i]=INT_MAX;
	for(int j=S;j<=T;j++)
		if(dp[i]>memo(i+j))
			dp[i]=memo(i+j);
	dp[i]+=bridge[i];
	return dp[i];
}
inline int cmp(const void *a,const void *b){
	return *(long*)a-*(long*)b;
}
int main(){
	ifstream cin("river.in");
	cin >> L_orig >> S >> T >> M;
	if(S==T)
		for(int i=1,tmp;i<=M;i++){
			cin >> tmp;
			if(tmp%S==0)	ans++;
		}
	else{
		pos[M+1]=L_orig;
		for(int i=1,counter=0;i<=M;i++)	cin >> pos[i];
		qsort(pos,M+2, sizeof(pos[0]),cmp);
		for(int i=1;i<=M+1;i++){
			if(pos[i]-pos[i-1]-1<=100)	L+=pos[i]-pos[i-1];
			else	L+=100;
			bridge[L]=1;
		}
		ans=memo(0);
	}
	ofstream fout("river.out");
	fout << ans << endl;
	return 0;
}

可能你对下面的文章也感兴趣：

1. [VIJOS 1037]搭建双塔
2. [VIJOS 1006]晴天小猪历险记之 Hill
3. [NOI99]棋盘分割(Chessboard Division)

2^K进制数

【题目描述】

设r是个2^k 进制数，并满足以下条件：

（1）r至少是个2位的2^k进制数。

（2）作为2^k进制数，除最后一位外，r的每一位严格小于它右边相邻的那一位。

（3）将r转换为2进制数q后，则q的总位数不超过w。

在这里，正整数k（1≤k≤9）和w（k<w≤30000）是事先给定的。

问：满足上述条件的不同的r共有多少个？

我们再从另一角度作些解释：设S是长度为w 的01字符串（即字符串S由w个“0”或“1”组成），S对应于上述条件（3）中的q。将S从右起划分为若干个长度为k 的段，每段对应一位2k进制的数，如果S至少可分成2段，则S所对应的二进制数又可以转换为上述的2k 进制数r。

例：设k=3，w=7。则r是个八进制数（23=8）。由于w=7，长度为7的01字符串按3位一段分，可分为3段（即1，3，3，左边第一段只有一个二进制位），则满足条件的八进制数有：

2位数：高位为1：6个（即12，13，14，15，16，17），高位为2：5个，…，高位为6：1个（即67）。共6+5+…+1=21个。

3位数：高位只能是1，第2位为2：5个（即123，124，125，126，127），第2位为3：4个，…，第2位为6：1个（即167）。共5+4+…+1=15个。

所以，满足要求的r共有36个。

【输入】

输入只有1行，为两个正整数，用一个空格隔开：k W

【输出】

输出为1行，是一个正整数，为所求的计算结果，即满足条件的不同的r的个数（用十进制数表示），要求最高位不得为0，各数字之间不得插入数字以外的其他字符（例如空格、换行符、逗号等）。

（提示：作为结果的正整数可能很大，但不会超过200位）

【样例输入】

3 7

【样例输出】

36

【题解】

想起去年NOIP做到这题时，我还是巨巨巨巨巨巨巨菜，看了这题的标题就直接放弃了……现在看来这题也不是那么难的。

题目中“从另一角度作些解释”是很重要的，这几乎直接给我们提供了算法（往下看之前请仔细阅读题目中的相关部分）。令N为2^k进制数的最大允许位数，\(a_0\) 为最高位允许的最大值，则有：

$$N= \left\lceil \frac{W}{K} \right\rceil$$ $$a_0=2^{W \mod K}-1$$

那么问题其实就等同于：取N个数（对应于\(2^k\)进制数中的N位），第1个数num[1]（对应于最高位）取值范围为[1,a0]，其余第2~N个数num[i]取值范围都为[1,2^K)。现从其中第i(\( 1 \leq i \leq N-1\))个数num[i]开始取数，一直取到最后一个数num[N]，要求对于任意的j>i满足num[j-1]<num[j]。问取数方案的总数。这就是很基础的组合数学问题了。

先不考虑第1个数，因为限制一个最大值会稍微麻烦一点。我们考虑一般情况。显然，如果取后i个数（\( 2 \leq i < N \)），可供选择的数有 \(2^k-1\) 个，则方案总数就为 \(C(i,2^k-1)\)。因此，从第2~N个数开始取的方案总数就为：$$\sum_{i=2}^{n-1}C_{2^k-1}^i$$

如果从第1个数开始取，则第1个数有1~\(a_0\)共\(a0\)个选择。如果选择a(\(1 \leq a \leq a_0\))，那么[1,\(2^K\))范围内剩下比a大的数就有\(2^k-a-1\)个，剩下N-1个数的可能选择方案就有\(C(2^k-i-1,n-1)\)个。那么从第1个数开始取的总方案数就为：$$\sum_{a=1}^{a_0}C_{2^k-a-1}^{n-1}$$

综上，要求的总方案数就为：$$ans=\sum_{a=1}^{a_0}C_{2^k-a-1}^{n-1}+\sum_{i=2}^{n-1}C_{2^k-1}^i$$

其中组合数\(C(N,K)\)可以利用下面递推式加上一点记忆化来在最短时间内计算得出 $$C_n^k=C_{n-1}^{k-1}+C_{n-1}^k$$

现在按照这个写应该会很简单了。这个如果用Pascal的int64据说能过7个点，用C++的unsigned long long则能过8个，性价比相当高了。但要想AC唯有高精。

源码：

#include <iostream>
#include <fstream>
#include <cmath>
#include <cassert>
#define SIZE 400
using namespace std;
class _int{
	int b[SIZE],l;
public:
	_int(){};
	_int(int n);
	int& operator()(const int&pos){return b[pos];}
	friend const _int operator+(const _int& b1,const _int& b2);
	friend ostream& operator<<(ostream& is,const _int& b);
};
_int::_int(int n){
	memset(b,0,sizeof(b));
	l=0;
	while(n!=0)
		b[l]=n%10,n/=10,l++;
}
const _int operator+(const _int& b1,const _int& b2){
	_int Ans=_int(0);
	Ans.l=b1.l;
	if(Ans.l<b2.l) Ans.l=b2.l;
	for(int i=0;i<Ans.l;i++) Ans.b[i]=b1.b[i]+b2.b[i];
	for(int i=0;i<Ans.l;i++){
		Ans.b[i+1]+=Ans.b[i]/10;
		Ans.b[i]%=10;
		if(Ans.b[Ans.l]!=0) Ans.l++;
	}
	return Ans;
}
ostream& operator<<(ostream& os,const _int& b){
	for(int i=b.l-1;i>=0;i–) os<<b.b[i];
	return os;
}
const unsigned pow2[10]={1,2,4,8,16,32,64,128,256,512};
unsigned K,W,N,a0;
_int ans,c[512][512];
bool flag[512][512];
_int C(int n,int k){
	if(n<k)	return _int(0);
	if(n==k||k==0)	return _int(1);
	assert(n<512);
	if(flag[n][k])	return c[n][k];
	flag[n][k]=1;
	return c[n][k]=C(n-1,k-1)+C(n-1,k);
}
int main(){
	ifstream cin("digital.in");
	cin >> K >> W;
	N=long(ceil(double(W)/K));
	a0=pow2[W%K]-1!=0?pow2[W%K]-1:pow2[K];
	for(int i=1;i<=a0&&pow2[K]-i-1>=N-1;i++)	ans=ans+C(pow2[K]-i-1,N-1);
	for(int i=2;i<=N-1&&pow2[K]-1>=i;i++)	ans=ans+C(pow2[K]-1,i);
	ofstream cout("digital.out");
	cout << ans << endl;
	return 0;
}

可能你对下面的文章也感兴趣：

1. [VIJOS 1014]旅行商简化版
2. [USACO]Arithmetic Progressions
3. [NOI99]棋盘分割(Chessboard Division)

晴天小猪历险记之 Hill

【背景 Background】

在很久很久以前，有一个动物村庄，那里是猪的乐园（^_^），村民们勤劳、勇敢、善良、团结……

不过有一天，最小的小小猪生病了，而这种病是极其罕见的，因此大家都没有储存这种药物。所以晴天小猪自告奋勇，要去采取这种药草。于是，晴天小猪的传奇故事便由此展开……

【描述 Description】

这一天，他来到了一座深山的山脚下，因为只有这座深山中的一位隐者才知道这种药草的所在。但是上山的路错综复杂，由于小小猪的病情，晴天小猪想找一条需时最少的路到达山顶，但现在它一头雾水，所以向你求助。

山用一个三角形表示，从山顶依次向下有1段、2段、3段等山路，每一段用一个数字T（1<=T<=100）表示，代表晴天小猪在这一段山路上需要爬的时间，每一次它都可以朝左、右、左上、右上四个方向走（**注意**：在任意一层的第一段也可以走到本层的最后一段或上一层的最后一段）。

晴天小猪从山的左下角出发，目的地为山顶，即隐者的小屋。

【输入格式 Input Format】

第一行有一个数n（2<=n<=1000），表示山的高度。

从第二行至第n+1行，第i+1行有i个数，每个数表示晴天小猪在这一段山路上需要爬的时间。

【输出格式 Output Format】

一个数，即晴天小猪所需要的最短时间。

【样例输入 Sample Input】

5
1
2 3
4 5 6
10 1 7 8
1 1 4 5 6

【样例输出 Sample Output】

10

【时间限制 Time Limitation】

各个测试点1s

【题解 Solution】

题目里说：在任意一层的第一段也可以走到本层的最后一段或上一层的最后一段。我们需要加上一句：反之亦然；这样就可以做了。

这是挺有意思的一题。对我这样的初学者来说，也是不算水题了。这题的原型来自经典的数字三角形，但是条件有所修改。题目简要描述如下：

给出一个N行数字三角形，其中第i行有i列。记i行j列的数字为(i,j)，则求从(1,N)到(1,1)的一条路径，要求路径上的数字之和最小。移动规则为：到达(i,j)位置时只能向左、右、左上、右上四个方向移动。特殊地，三角形左右互通，即由(i,1)可移动到(i,i)或(i-1,i-1)；(i,i)同理。

的确和经典的数字三角形很像吧，仅仅在移动规则上加了两条：1.允许同行的左右移动；2.左右互通。但是加上这小小的两个条件，题目就大不一样了。

下面是三种方法，但事实上前两种都是扯淡，是我在思考时得到的不可行方法。建议直接跳到第三条分割线之后。

注：各转移方程都没有把行两端情况单另写出来……

———————————第1条分割线凌空飞过—————————————

既然和经典问题这么像，那我们就先按照经典的方程来做吧。在经典方程上简单加上向左、向右两个决策，这样行不行呢？显然，现在出现了两种环，一种是向一个方向走再折回来，一种是一直走到行首或行末，然后绕一个大圈回来。这两种环的存在导致了后效性的产生。当然，这时候递归下降还是可行的（用一个bool数组记录哪些点已经到达），但是复杂度无疑是巨大的指数级。我就这么交了一次，结果一个点都没过……-_-

———————————第2条分割线凌空飞过—————————————

这样改动后真的失去无后效性了么？引起这一变化的原因就是同行内的移动，那我们就从同行内的移动考虑。在同行内移动时，一定是从左或从右直接移动到某一个点，然后向上移；绝对不会在一行里面走回头路，也不会赖在一行里不走的。这样，行间转移的无后效性就很明显了。若用dp(i,j)表示(i,j)到(1,1)的路径最小权和，sum(i,j,k)表示第i行中j列到k列的路径最小权和，很容易写出下面的方程：

dp(i,j)=min{ sum(i,j,k)+min{dp(i-1,j),dp(i-1,j-1)} } (1<=k<=i)

其中，sum(i,j,k)可以在O(1)时间内获得。DP的子问题数是O(N^2)的，转移是O(N)的，这样复杂度就是O(N^3)的，对N<=1000这个数据规模还是太大了。至于能得多少分，由于我没写，就不知道了。

———————————第3条分割线凌空飞过—————————————

事实上我们可以利用同行内的递推关系来获得O(N^2)的算法。我们把在第一条分割线下被否定的方程写出来：

dp(i,j)=min{ min{dp(i-1,j),dp(i-1,j)},dp(i,j-1),dp(i,j+1) }+num(i,j)

其中num(i,j)即为位置(i,j)上的数。即对于一个点(i,j)，或者上移至前一行，或者在本行内向左或向右移动。由于不走回头路，若一个点(i,j)的dp值由左边的点(i,j-1)转移得到，则(i,j-1)也必由它自己的左边的点(i,j-2)或前一行转移得到而不必考虑向右。即：

若dp(i,j)=dp(i,j-1)+num(i,j)

则必有dp(i,j-1)=min{ dp(i,j-2),min{dp(i-1,j-2),dp(i-1,j-1)} }+num(i,j-1)（不必考虑转移到dp(i,j)）

向右转移时也是同理。

现需找一个行内递推的起点。我们可取此行内min{dp(i-1,j),dp(i-1,j-1)}+num(i,j)最小的一点，因为它的dp值只能由上一行转移得到。以此为起点，向左向右分别推一圈，就得到了整行内的dp值。

就写这么多……感觉越写越乱了……还是看代码吧：

/*
  Name: Vijos P1006 晴天小猪历险记之Hill
  Author: 巨菜逆铭
  Date: 24-08-07 18:58
  Description: Dynamic Programming
*/

#include <iostream>
#include <fstream>
#include <cassert>
#define SYS sys\
tem
using namespace std;
unsigned long N,num[1001],dp[2][1002];
int main(){
	//The Amulet
	unsigned rp=unsigned(-1);

	//ifstream cin("input.txt");
	cin >> N >> dp[0][1];
	dp[0][0]=dp[0][2]=dp[0][1];
	bool flag=1;
	for(int i=2;i<=N;i++,flag=!flag){
		int m,m_num=INT_MAX;
		for(int j=1;j<=i;j++){
			cin >> num[j];
			dp[flag][j]=num[j]+min(dp[!flag][j],dp[!flag][j-1]);
			if(m_num>dp[flag][j])	m=j,m_num=dp[flag][j];
		}
		//walk rightward
		for(int j=m+1;j<=i;j++)
			if(dp[flag][j]>dp[flag][j-1]+num[j])
				dp[flag][j]=dp[flag][j-1]+num[j];
		if(dp[flag][1]>dp[flag][i]+num[1])
			dp[flag][1]=dp[flag][i]+num[1];
		for(int j=2;j<m;j++)
			if(dp[flag][j]>dp[flag][j-1]+num[j])
				dp[flag][j]=dp[flag][j-1]+num[j];
		//walk leftward
		for(int j=m-1;j>=1;j--)
			if(dp[flag][j]>dp[flag][j+1]+num[j])
				dp[flag][j]=dp[flag][j+1]+num[j];
		if(dp[flag][i]>dp[flag][1]+num[i])
			dp[flag][i]=dp[flag][1]+num[i];
		for(int j=i-1;j>m;j--)
			if(dp[flag][j]>dp[flag][j+1]+num[j])
				dp[flag][j]=dp[flag][j+1]+num[j];
		//special step for convenience
		dp[flag][0]=dp[flag][i];
		dp[flag][i+1]=dp[flag][1];
	}
	cout << dp[!flag][1] << endl;
	//SYS("pause");
	return 0;
}

可能你对下面的文章也感兴趣：

1. [vijos P1092] 全排列
2. [URAL1028]Stars (Using SBT, SBST, VBST)
3. [VIJOS 1014]旅行商简化版

旅行商简化版

【背景 Background】

欧几里德旅行商(Euclidean Traveling Salesman)问题也就是货郎担问题一直是困扰全世界数学家、计算机学家的著名问题。现有的算法都没有办法在确定型机器上在多项式时间内求出最优解，但是有办法在多项式时间内求出一个较优解。

为了简化问题，而且保证能在多项式时间内求出最优解，J.L.Bentley提出了一种叫做bitonic tour的哈密尔顿环游。它的要求是任意两点(a,b)之间的相互到达的代价dist(a,b)=dist(b,a)且任意两点之间可以相互到达，并且环游的路线只能是从最西端单向到最东端，再单项返回最西端，并且是一个哈密尔顿回路。

【描述 Description】

著名的NPC难题的简化版本

现在笛卡尔平面上有n(n<=1000)个点，每个点的坐标为(x,y)(-2^31<x,y<2^31，且为整数)，任意两点之间相互到达的代价为这两点的欧几里德距离，现要你编程求出最短bitonic tour。

【输入格式 Input Format】

第一行一个整数n

接下来n行，每行两个整数x,y，表示某个点的坐标。

输入中保证没有重复的两点，保证最西端和最东端都只有一个点。

【输出格式 Output Format】

一行，即最短回路的长度，保留2位小数。

【样例输入 Sample Input】

7
0 6
1 0
2 3
5 4
6 1
7 5
8 2

【样例输出 Sample Output】

25.58

【时间限制 Time Limitation】

1s

【来源 Source】

《算法导论（第二版）》 15-1

【题解 Solution】

基本DP。

这题需要补充一个条件：任何两点的x坐标都不相等。

首先按照x坐标对所有点进行排序，并从西到东依次编号。这样我们就可以进行DP了。阶段可以按照从西到东的各个点来划分。

如图，我们对E点代表的阶段进行决策，有两种决策：E连B或E连D。这样，类似B、D的两个点就可以表示一种状态。

我们用dp[i][j]表示一种状态，表示在这两个点代表的状态之后，还能得到的最小长度。则有

dp[i][j]=dp[j][i]=min{dp[i][k]+dist[j][k],dp[k][j]+dist[i][k]}

(k=max(i,j)+1)

dp[0][0]就是所求的解。边界也很好处理。时间复杂度为O(N^2)。

源码：

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <cmath>
using namespace std;
double dp[1000][1000],dist[1000][1000];
int N;
struct Dot{	long x,y;}dots[1000];
int cmp(const void *a, const void *b){
	return ((Dot*)a)->x-((Dot*)b)->x;
}
double memo(int a, int b){
	if(dp[a][b]>0)	return dp[a][b];
	if(a==N-1)	return dist[N-1][b];
	if(b==N-1)	return dist[N-1][a];
	int c=max(a,b)+1;
	return dp[b][a]=dp[a][b]=min(memo(a,c)+dist[b][c],memo(c,b)+dist[a][c]);
}
int main(){
	cin >> N;
	for(int i=0;i<N;i++)
		cin >> dots[i].x >> dots[i].y;
	qsort( dots, N, sizeof(dots[0]), cmp );
	for(int i=0;i<N;i++)
		for(int j=i+1;j<N;j++){
			double x=dots[i].x-dots[j].x,y=dots[i].y-dots[j].y;
			dist[i][j]=dist[j][i]=sqrt(x*x+y*y);
		}
	cout << fixed << setprecision(2) <<memo(0,0) << endl;
	return 0;
}

可能你对下面的文章也感兴趣：

1. [NOI 05]聪聪与可可
2. [NOI99]棋盘分割(Chessboard Division)
3. [01ACM NEEuropean][URAL1183]Brackets sequence

聪聪与可可

主文件名：cchkk

时限：1s

【问题描述】

在一个魔法森林里，住着一只聪明的小猫聪聪和一只可爱的小老鼠可可。虽然灰姑娘非常喜欢她们俩，但是，聪聪终究是一只猫，而可可终究是一只老鼠，同样不变的是，聪聪成天想着要吃掉可可。

一天，聪聪意外得到了一台非常有用的机器，据说是叫GPS，对可可能准确的定位。有了这台机器，聪聪要吃可可就易如反掌了。于是，聪聪准备马上出发，去找可可。而可怜的可可还不知道大难即将临头，仍在森林里无忧无虑的玩耍。

小兔子乖乖听到这件事，马上向灰姑娘报告。灰姑娘决定尽快阻止聪聪，拯救可可，可她不知道还有没有足够的时间。

整个森林可以认为是一个无向图，图中有N个美丽的景点，景点从1至N编号。小动物们都只在景点休息、玩耍。在景点之间有一些路连接。

当聪聪得到GPS时，可可正在景点M(M≤N)处。以后的每个时间单位，可可都会选择去相邻的景点(可能有多个)中的一个或停留在原景点不动。而去这些地方所发生的概率是相等的。假设有P个景点与景点M相邻，它们分别是景点R、景点S，……景点Q，在时刻T可可处在景点M，则在(T＋1)时刻，可可有1/(P+1)的可能在景点R，有1/(P+1)的可能在景点S，……，有1/(P+1)的可能在景点Q，还有1/(P+1)的可能停在景点M。

我们知道，聪聪是很聪明的，所以，当她在景点C时，她会选一个更靠近可可的景点，如果这样的景点有多个，她会选一个标号最小的景点。由于聪聪太想吃掉可可了，如果走完第一步以后仍然没吃到可可，她还可以在本段时间内再向可可走近一步。

在每个时间单位，假设聪聪先走，可可后走。在某一时刻，若聪聪和可可位于同一个景点，则可怜的可可就被吃掉了。

灰姑娘想知道，平均情况下，聪聪几步就可能吃到可可。而你需要帮助灰姑娘尽快的找到答案。

【输入格式】

从文件cchkk.in中读入数据。

数据的第1行为两个整数N和E，以空格分隔，分别表示森林中的景点数和连接相邻景点的路的条数。

第2行包含两个整数C和M，以空格分隔，分别表示初始时聪聪和可可所在的景点的编号。

接下来E行，每行两个整数，第i+2行的两个整数Ai和Bi表示景点Ai和景点Bi之间有一条路。

所有的路都是无向的，即：如果能从A走到B，就可以从B走到A。

输入保证任何两个景点之间不会有多于一条路直接相连，且聪聪和可可之间必有路直接或间接的相连。

【输出格式】

输出到文件cchkk.out中。

输出1个实数，四舍五入保留三位小数，表示平均多少个时间单位后聪聪会把可可吃掉。

【输入样例1】

 4 3 1 4 1 2 2 3 3 4

【输出样例1】

1.500

【输入样例2】

 9 9 9 3 1 2 2 3 3 4 4 5 3 6 4 6 4 7 7 8 8 9

【输出样例2】

2.167

【数据范围】

对于所有的数据，1≤N,E≤1000。

对于50%的数据，1≤N≤50。

【题解】

NOI还有这么简单的题么……引用Ivan的话：是人就会做。汗，这话说的我做出来以后一点成就感都没有。

唯一一点要注意的就是别让题目阴了。“灰姑娘想知道，平均情况下，聪聪几步就可能吃到可可。”按着这个做就挂了。一定得看清楚样例分析（我这没贴），否则怎么知道这个“步”是指回合而不是真的指具体的步呢。

要拿50分，floyd预处理+递归下降。要拿满分，bfs预处理+记忆化。我这里用的是spfa，纯是为了复习。好像spfa还快点（bfs我也写了）。

源码：

#include <fstream>
#include <iomanip>
using namespace std;
int V,E,C,K;//节点数、边数、聪聪和可可的初始位置
short neighbor[1001][1001];//[i][0]:节点i连接的边数;[i][j]:节点i的第j个邻居
unsigned short dist[1001][1001];//[i][j]:i、j两点间的最短距离
double dp[1001][1001];
bool walk(short &c,short k){//让聪聪向可可走一步，并返回是否能吃到
    for(short j=1,c0=c,cc;j<=neighbor[c0][0];j++){
        cc=neighbor[c0][j];
        if(dist[c][k]>dist[cc][k]||(dist[c][k]==dist[cc][k]&&c>cc))
            c=cc;
    }
    return c==k;
}
double memo(short c,short k){
    short c0=c;
    if(dp[c][k]>0)    return dp[c][k];
    if(c==k)    return 0;
    if(walk(c,k)||walk(c,k))    return 1;//这句话诡异吧^^
    double ans=memo(c,k);
    for(short j=1;j<=neighbor[k][0];j++)
        ans+=memo(c,neighbor[k][j]);
    ans/=(neighbor[k][0]+1);
    return dp[c0][k]=ans+1;
}
int main(){
    ifstream fin("cchkk.in");
    ofstream fout("cchkk.out");
    fin >> V >> E >> C >> K;
    for(int i,j,k=0;k<E;k++){
        fin >> i >> j;
        neighbor[i][++neighbor[i][0]]=j;
        neighbor[j][++neighbor[j][0]]=i;
    }
    //用SPFA来预处理任意两点间的最短距离
    memset(dist,-1,sizeof(dist));
    for(int s=1;s<=V;s++){
        short queue[1001],head=0,tail=1;
        bool inqueue[1001]={0};
        queue[0]=s,dist[s][s]=0;
        while(head<tail){
            short u = queue[head++];
            inqueue[u]=false;
            if(head>1000)    head=0;
            for(short j=1,v;j<=neighbor[u][0];j++){
                v=neighbor[u][j];
                if(dist[s][v]>dist[s][u]+1){
                    dist[s][v]=dist[s][u]+1;
                    if(!inqueue[v]){
                        queue[tail++]=v,inqueue[v]=true;
                        if(tail>1000)    tail=0;
                    }
                }
            }
        }
    }
    fout << fixed << setprecision(3) << memo(C,K) << endl;
    return 0;
}

可能你对下面的文章也感兴趣：

1. [NOI99]棋盘分割(Chessboard Division)
2. [NOI97]积木游戏(Game)
3. [POI VI Stage 1 Problem 1] Musketeers

第二十三届全国信息学奥林匹克竞赛
NOI 2006
第一试

生日快乐

【任务描述】

今天是栋栋的生日，他邀请了N 个好友参加Party 。朋友们都知道，栋栋最喜欢吃果冻。因此, 每个朋友带来的生日礼物全是一包果冻.。

在每个朋友送他一包果冻的同时，栋栋还要这个朋友送他一个幸运号码L（1 ≤ L ≤ N）。然后栋栋会先把这包果冻放在一旁，并且把之前的所有果冻包按照果冻的数量从小到大排序（如果果冻数量相等，先后顺序任意）。接着，栋栋再把当前这包果冻插入到有序的果冻包队列中，使得这个队列仍然有序（如果存在其他的果冻包与该果冻包数量相等，则把该果冻包放在它们的前面）。完成这个操作后，栋栋就会进行如下操作：

“如果这个朋友是男生，栋栋会从他送的包的后一个包开始向后数L 个（该朋友的幸运号码），从那个包里取出一个果冻，吃掉。

“如果这个朋友是女生，栋栋会从她送的包的前一个包开始向前数L 个（该朋友的幸运号码），从那个包里取出一个果冻，吃掉。

栋栋实在是太粗心了，以至于他收完所有的礼物后，都不知道吃过哪些朋友的果冻，现在，他希望你帮他一下，当他每吃一个果冻后马上告诉他可能吃的是谁送的(由于排序不是确定的，所以栋栋只要你给他一种可能的答案就行了)。

这是一个交互式的题目，你必须调用库函数来完成所有操作而不能访问任何文件。

【数据规模和约定】

对于所有的数据，我们保证：1 ≤ n ≤ 500000，0 ≤ count ≤ 10^8 ，1 ≤ luckynumber ≤ n.在测试时，你的数据也应该满足我们的数据范围，否则有可能运行异常。

【题解】

平衡树的的典型应用。我这里对SBT(Size Balanced Tree)进行2处改写来做这题：首先是在Insert过程中返回插入节点的秩，这是一个顺便的改动，非常简单；再就是在Delete和Select的基础上改写出了SBT_Select_Delete，即选择指定秩的节点删除，并返回此节点。这个也不难，看看我的代码就知道了。只是注意，既然删除的节点要回收利用，那么从树中删除后就需要处理清楚size和ch[]域。

BTW，题目中给的count范围包括0，这是不负责任的。仔细想想就发现一旦出现这样的节点你就无法确定该如何处理了。当然了，评测时并没有给出这样的数据，否则鬼知道怎么处理呢。

时空开销：

代码：

#include "happybirthday_lib_c.cpp"
struct SBTNode{
	SBTNode *ch[2];
	long size, key, id;
	SBTNode(long _key, long _id, long _size);
}NIL=SBTNode(0,0,0);
SBTNode::SBTNode(long _key, long _id, long _size=1){
	key=_key,id=_id,size=_size;
	ch[0]=ch[1]=&NIL;
}
typedef SBTNode* SBTree;
void SBT_Rotate(SBTree &x, bool flag){
	SBTNode *y = x->ch[!flag];
	x->ch[!flag]=y->ch[flag],y->ch[flag]=x;
	y->size=x->size;
	x->size=x->ch[0]->size+x->ch[1]->size+1;
	x=y;
}
void SBT_Maintain(SBTree &T,bool flag){
	if(T->ch[flag]->ch[flag]->size>T->ch[!flag]->size)
		SBT_Rotate(T,!flag);
	else if(T->ch[flag]->ch[!flag]->size>T->ch[!flag]->size)
		SBT_Rotate(T->ch[flag],flag),SBT_Rotate(T,!flag);
	else return;
	SBT_Maintain(T->ch[0],0),SBT_Maintain(T->ch[1],1);
	SBT_Maintain(T,0),SBT_Maintain(T,1);
}
long SBT_Insert(SBTree &T, SBTNode *toAdd){
	if(T==&NIL){
		T=toAdd;
		return 1;
	}else{
		T->size++;
		bool flag=toAdd->key>T->key;
		long r=SBT_Insert(T->ch[flag],toAdd)+(flag?T->ch[0]->size+1:0);
		SBT_Maintain(T,flag);
		return r;
	}
}
SBTNode *SBT_Select_Delete(SBTree &T,long i){
	if(T==&NIL)	return &NIL;
	T->size--;
	unsigned long r = T->ch[0]->size + 1;
	if(i==r){
		SBTNode *toDel = NULL;
		if(T->ch[0]==&NIL||T->ch[1]==&NIL){
			toDel=T;
			T=T->ch[T->ch[1]!=&NIL];
		}else{
			toDel = SBT_Select_Delete(T->ch[1],1);
			swap(T->key,toDel->key),swap(T->id,toDel->id);
		}
		toDel->ch[0]=toDel->ch[1]=&NIL;
		toDel->size=1;
		return toDel;
	}
	else return SBT_Select_Delete(T->ch[i>r],i>r?i-r:i);
}
int main(){
	long c,l,r,id=1; bool isboy;
	SBTNode *toEat; SBTree T=&NIL;
	for(init();getpresent(c,l,isboy);id++){
		SBTNode *toAdd = new SBTNode(c,id);
		r = SBT_Insert(T,toAdd);
		if(isboy)	r+=l;
		else r-=l;
		if(r<=0||r>T->size) tell(-1);
		else{
			toEat = SBT_Select_Delete(T,r);
			tell(toEat->id);
			if(--toEat->key>0)	SBT_Insert(T,toEat);
			else delete toEat;
		}
	}
	return 0;
}

P.S.有一件事情很郁闷，那就是……这题用不着平衡树-_-|||

因为数据都是random的，普通BST表现反倒会更好。。。（但是比赛时谁知道呢）

可能你对下面的文章也感兴趣：

1. Size Balanced Tree in C++
2. [URAL1028]Stars (Using SBT, SBST, VBST)
3. [CEOI99][POJ1733][URAL1003][VIJOS1112]Parity Game

Parity Game

Time Limit:1000MS

Memory Limit:65536K

Description

Now and then you play the following game with your friend. Your friend writes down a sequence consisting of zeroes and ones. You choose a continuous subsequence (for example the subsequence from the third to the fifth digit inclusively) and ask him, whether this subsequence contains even or odd number of ones. Your friend answers your question and you can ask him about another subsequence and so on. Your task is to guess the entire sequence of numbers.

You suspect some of your friend’s answers may not be correct and you want to convict him of falsehood. Thus you have decided to write a program to help you in this matter. The program will receive a series of your questions together with the answers you have received from your friend. The aim of this program is to find the first answer which is provably wrong, i.e. that there exists a sequence satisfying answers to all the previous questions, but no such sequence satisfies this answer.

Input

The first line of input contains one number, which is the length of the sequence of zeroes and ones. This length is less or equal to 1000000000. In the second line, there is one positive integer which is the number of questions asked and answers to them. The number of questions and answers is less or equal to 5000. The remaining lines specify questions and answers. Each line contains one question and the answer to this question: two integers (the position of the first and last digit in the chosen subsequence) and one word which is either ‘even’ or ‘odd’ (the answer, i.e. the parity of the number of ones in the chosen subsequence, where ‘even’ means an even number of ones and ‘odd’ means an odd number).

Output

There is only one line in output containing one integer X. Number X says that there exists a sequence of zeroes and ones satisfying first X parity conditions, but there exists none satisfying X+1 conditions. If there exists a sequence of zeroes and ones satisfying all the given conditions, then number X should be the number of all the questions asked.

Example

Example 1:

PARITY.IN

10
5
1 2 even
3 4 odd
5 6 even
1 6 even
7 10 odd

PARITY.OUT

3

Example 2:

PARITY.IN

10
5
1 2 even
1 4 even
2 4 odd
1 10 even
3 10 even

PARITY.OUT

5

Solution

挖个坑先……要是比赛中的话我怎么可能想到这题是并查集呢！

终于搞定。

首先有一步关键转化要做。我们同时处理一个范围内数字1的个数的奇偶比较麻烦。如果a到b之间有n个1，那么可以看成0到b之间1的个数减去0到a-1之间1的个数为n。我们假想知道了所有1的位置，那么0到任意i之间1的个数就是确定的。也就是说，通过这种转化，数据范围内每个数都对应了一个确定的数，它表示0到此数之间数字1的个数。

而我们事实上并不知道这些数确切是什么。我们知道的是一些数对之间奇偶性的关系。而这种关系是可以传递转移的。我们需要判断在给出关系的过程中是否出现矛盾。

于是就可以用并查集来解决这个问题了。它与我前面做过的食物链相比，本质上是一样的，但是处理起来还简单。你可以参照那个题的题解来理解这个题。

除了这步转化以外，对我而言处理起来比较麻烦的就是离散化了。这题串最大长度为10亿，而仅仅给出最多5千条询问，明显不离散化是不行了。我用的Hash。Hash和并查集的联合我从前是没搞过的。

P.S.这题其实是个骗分的好题（ACMer们别打我。。。）。不离散化最少70分。如果内存放宽一点就有80分。即使奇偶搞反了都有50分……总之怎么着都能得分的。CEOI的标程好像不是用并查集做的，但是要慢一些。就不管它了。

时空开销：

URAL的数据ms有问题，就再不管了。

源码：

#include <fstream>
#include <string>
using namespace std;
const long P=29989;
const string odd="odd";
long N,K;
struct elem{
	long key,rank;
	bool p_r;//false means same
	elem *next,*p;
	elem(long _key){key=_key,rank=0,p=this,p_r=false,next=NULL;}
}*set[P];
elem* Hash_Search(long key){
	elem* p=set[key%P];
	while(p&&p->key!=key)	p=p->next;
	return p;
}
void Hash_Insert(elem* toAdd){
	long h = toAdd->key%P;
	toAdd->next=set[h];
	set[h]=toAdd;
}
elem *Set_Find(elem* A, bool &ch_r){
	if(A->p!=A){
		A->p=Set_Find(A->p,A->p_r);
		ch_r=(ch_r!=A->p_r);
	}
	return A->p;
}
bool istrue(long a,long b, bool flag){
	bool tmp=0;
	elem *A=Hash_Search(a),*B=Hash_Search(b);
	if(!A)	A = new elem(a),Hash_Insert(A);
	if(!B)	B = new elem(b),Hash_Insert(B);
	if(Set_Find(A,tmp)!=Set_Find(B,tmp)) return true;
	if(!flag) return A->p_r==B->p_r;
	else return A->p_r!=B->p_r;
}
void Set_Union(long a,long b, bool flag){
	elem *A=Hash_Search(a),*B=Hash_Search(b);
	if(!A)	A = new elem(a),Hash_Insert(A);
	else A=Set_Find(A,flag);
	if(!B)	B = new elem(b),Hash_Insert(B);
	else B=Set_Find(B,flag);
	if(A==B)	return;
	if(A->rank<B->rank)	A->p=B,A->p_r=flag;
	else{
		B->p=A,B->p_r=flag;
		if(A->rank==B->rank)	A->rank++;
	}
}
int main(){
	ifstream fin("PARITY.IN");
	ofstream fout("PARITY.OUT");
	fin >> N >> K;
	unsigned long a,b,ans=0;
	string parity;
	for(ans=1;ans<=K;ans++){
		fin >> a >> b >> parity;
		bool flag = parity==odd;//false means same
		if(istrue(a-1,b,flag))	Set_Union(a-1,b,flag);
		else break;
	}
	fout << --ans << endl;
	fin.close(),fout.close();
	return 0;
}

可能你对下面的文章也感兴趣：

1. Size Balanced Tree in C++
2. [NOI 01][POJ1182] 食物链
3. [URAL1028]Stars (Using SBT, SBST, VBST)

描述 Description

输入两个自然数m,n 1<=n<=20，1<=m<=n!

输出n个数的第m种全排列。

如 ：

输入 3 1

输出 1 2 3

输入格式 Input Format

在一行中输入n m

输出格式 Output Format

一个数列,既n个数的第m种排列

每两个数之间空1格

样例输入 Sample Input

3 2

样例输出 Sample Output
1 2 3
时间限制 Time Limitation

各个测试点1s

题解 Solution

简单的康托展开应用。借以复习之。

#include <iostream>
using namespace std;
int main(){
	int n;
	long long m,f[21]=
{1LL,1LL,2LL,6LL,24LL,120LL,720LL,5040LL,40320LL,362880LL,3628800LL,39916800LL,
479001600LL,6227020800LL,87178291200LL,1307674368000LL,20922789888000LL,
355687428096000LL,6402373705728000LL,121645100408832000LL,2432902008176640000LL};
	bool num[20]={0};//[i]:mark for number i+1
	cin >> n >> m;
	m--;
	for(int i=n-1;i>=0;m%=f[i--]){
		int j = m/f[i], k=-1;
		//cout << m << ' ' << j << endl;
		while(j>=0)
			if(!num[++k])	j--;
		num[k]=true;
		cout << k+1 << ' ';
	}
	return 0;
}

可能你对下面的文章也感兴趣：

1. [USACO]Ordered Fractions
2. [IOI 01] Mobile Phones
3. [USACO]Friday the Thirteenth

银河英雄传说

时限：2s

【问题描述】

公元五八○一年，地球居民迁移至金牛座α第二行星，在那里发表银河联邦创立宣言，同年改元为宇宙历元年，并开始向银河系深处拓展。

宇宙历七九九年，银河系的两大军事集团在巴米利恩星域爆发战争。泰山压顶集团派宇宙舰队司令莱因哈特率领十万余艘战舰出征，气吞山河集团点名将杨威利组织麾下三万艘战舰迎敌。

杨威利擅长排兵布阵，巧妙运用各种战术屡次以少胜多，难免恣生骄气。在这次决战中，他将巴米利恩星域战场划分成30000列，每列依次编号为1, 2, …, 30000。之后，他把自己的战舰也依次编号为1, 2, …, 30000，让第i号战舰处于第i列(i = 1, 2, …, 30000)，形成“一字长蛇阵”，诱敌深入。这是初始阵形。当进犯之敌到达时，杨威利会多次发布合并指令，将大部分战舰集中在某几列上，实施密集攻击。合并指令为M i j，含义为让第i号战舰所在的整个战舰队列，作为一个整体（头在前尾在后）接至第j号战舰所在的战舰队列的尾部。显然战舰队列是由处于同一列的一个或多个战舰组成的。合并指令的执行结果会使队列增大。

然而，老谋深算的莱因哈特早已在战略上取得了主动。在交战中，他可以通过庞大的情报网络随时监听杨威利的舰队调动指令。

在杨威利发布指令调动舰队的同时，莱因哈特为了及时了解当前杨威利的战舰分布情况，也会发出一些询问指令：C i j。该指令意思是，询问电脑，杨威利的第i号战舰与第j号战舰当前是否在同一列中，如果在同一列中，那么它们之间布置有多少战舰。

作为一个资深的高级程序设计员，你被要求编写程序分析杨威利的指令，以及回答莱因哈特的询问。

最终的决战已经展开，银河的历史又翻过了一页……

【输入文件】

输入文件galaxy.in的第一行有一个整数T（1<=T<=500,000），表示总共有T条指令。

以下有T行，每行有一条指令。指令有两种格式：

1. M i j ：i和j是两个整数（1<=i , j<=30000），表示指令涉及的战舰编号。该指令是莱因哈特窃听到的杨威利发布的舰队调动指令，并且保证第i号战舰与第j号战舰不在同一列。
2. C i j ：i和j是两个整数（1<=i , j<=30000），表示指令涉及的战舰编号。该指令是莱因哈特发布的询问指令。

【输出文件】

输出文件为galaxy.out。你的程序应当依次对输入的每一条指令进行分析和处理：

如果是杨威利发布的舰队调动指令，则表示舰队排列发生了变化，你的程序要注意到这一点，但是不要输出任何信息；

如果是莱因哈特发布的询问指令，你的程序要输出一行，仅包含一个整数，表示在同一列上，第i号战舰与第j号战舰之间布置的战舰数目。如果第i号战舰与第j号战舰当前不在同一列上，则输出-1。

【题解】
并查集。把每个战舰队列作为一个集合。两个战舰队列的合并就可以看作两个集合的合并。
这里我们需要处理集合内元素间的关系：得到两个元素之间的元素个数。把所有元素按顺序储存需要的时候再数显然是不划算的。我们可以为每个节点维护一个dist域，记录此元素到到父节点的距离。显然如果要求两个元素i、j间的距离，我们需要先通过路径压缩使得他们的父节点统一为根，然后只要|dist[i]-dist[j]|-1就行了。
但是在合并两个集合时怎么维护dist呢？我们这里再引入一个size域，仅当i为战舰队列的头头时才有效。它表示集合中元素的个数。这样，在做合并时，就很容易维护dist了。问题解决。

代码：

#include <cstdio>
#include <cstdlib>
using namespace std;
struct Set_elem{ int p,size,dist; }set[30000+1];
int Root(int i){
	if(set[i].p!=i){
		int root=Root(set[i].p);
		set[i].dist+=set[set[i].p].dist;
		set[i].p=root;
	}
	return set[i].p;
}
int main(){
	for(int i=1;i<=30000;i++)	set[i].p=i,set[i].size=1;
	FILE *fin = fopen("galaxy.in","r"), *fout = fopen("galaxy.out","w");
	int T,i,j,ir,jr;	char oper;
	for(fscanf(fin,"%d\n",&T);T>0;T--){
		fscanf(fin,"%c %d %d\n",&oper,&i,&j);
		ir=Root(i), jr=Root(j);
		switch(oper){
			case 'M':
				set[ir].p=jr;
				set[ir].dist=set[jr].size;
				set[jr].size+=set[ir].size;
				break;
			case 'C':
				fprintf(fout,"%d\n",ir==jr?abs(set[i].dist-set[j].dist)-1:-1);
		}
	}
	fclose(fin),fclose(fout);
	return 0;
}

可能你对下面的文章也感兴趣：

1. [NOI 01][POJ1182] 食物链
2. [URAL1028]Stars (Using SBT, SBST, VBST)
3. [IOI 01] Mobile Phones

食物链

时限：3s

空间限制：64MB

eat.pas/c/cpp

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。

现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这N个动物所构成的食物链关系进行描述：

第一种说法是“1 X Y”，表示X和Y是同类。

第二种说法是“2 X Y”，表示X吃Y。

此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

1.当前的话与前面的某些真的话冲突，就是假话；

2.当前的话中X或Y比N大，就是假话；

3.当前的话表示X吃X，就是假话。

你的任务是根据给定的N（1<=N<=50,000）和K句话（0<=K<=100,000），输出假话的总数。

输入文件（eat.in）

第一行是两个整数N和K，以一个空格分隔。

以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。

若D=1，则表示X和Y是同类。

若D=2，则表示X吃Y。

输出文件（eat.out）

只有一个整数，表示假话的数目。

输入样例

输入文件  对7句话的分析
100 7
1 101 1  假话
2 1 2  真话
2 2 3  真话
2 3 3   假话
1 1 3  假话
2 3 1  真话
1 5 5  真话

输出样例

3

题解

郁闷死了……这本来是个弱题，我也想着两下搞定算了，结果从昨天下午搞到今晚才搞定。关系想不清楚就会越写越乱。

显然并查集。把已知的每一类动物看成一个集合。当我们得到（或推断出）两只动物是同类的信息时，我们需要合并它们所在的集合。

但是当我们处理捕食关系时怎么办呢？这就需要处理各个集合间的关系了。我这里使用了两个额外的域分别指向它的天敌和猎物集合中的一个元素（名字分别是killer和food……可见我英语很烂，给变量起名字也不在行）。每三个相关的集合构成一个关系组。我们就可以通过对这两个域的维护来处理一个集合与关系组内另外两个集合的关系了。

注意，我们不能一上来得到一组关系就说“好，那你就是A，你就是B吧”。因为我们在得到两个关系组中某两个集合的关系（包括同类和捕食）时需要合并两个关系组，而这时很明显会挂得很惨。我们只能维护各个关系组内的关系，在合并组时才不会出错。当关系组合并时，两个关系组将合二为一，我们就需要分别合并关系组内对应集合，并且维护它们的那两个额外的域。

在维护这两个域时需要想清楚，有没有漏掉的。不清楚就开写，只能像我一样越搞越乱。

我把文件IO改成stdio后交poj后得到的时空开销：

修改后还算清晰的代码：

#include <cstdio>
using namespace std;
struct Set{	long rank,p,food,killer; }set[50001];
long lie_sum,N,K;
long root(long x){
	if(set[x].p!=x)	set[x].p=root(set[x].p);
	return set[x].p;
}
long unite(long x, long y){
	x=root(x),y=root(y);
	if(x==y||x==0||y==0)	return x!=0?x:y;
	if(set[x].rank>set[y].rank)	set[y].p=x;
	else{
		set[x].p=y;
		if(set[x].rank==set[y].rank)	set[y].rank++;
	}
	set[x].food=set[y].food=unite(set[x].food,set[y].food);
	set[x].killer=set[y].killer=unite(set[x].killer,set[y].killer);
	return set[x].p;
}
void eat(long x, long y){
	x=root(x),y=root(y);
	if(root(set[x].food)==y)	return;
	set[y].killer=unite(x,set[y].killer);
	set[x].food=unite(y,root(set[x].food));
	set[x].killer=set[y].food=unite(set[x].killer,set[y].food);
	long z=set[x].killer;
	if(z!=0){
		set[z].killer=y;
		set[z].food=x;
	}
}
bool istrue(long oper, long x, long y){
	if(x>N||y>N)	return false;
	x=root(x),y=root(y);
	long xk=root(set[x].killer),xf=root(set[x].food);
	switch(oper){
		case 1:	return(x==0||y==0||x==y||xk!=y&&xf!=y);
		case 2:	return(x!=y&&(xk==0||xk!=y));
	}
}
int main(){
	FILE *fin=fopen("eat.in","r"),*fout=fopen("eat.out","w");
	fscanf(fin,"%ld%ld",&N,&K);
	for(long i=1;i<=N;i++)	set[i].p=i;
	for(long i=1,oper,x,y;i<=K;i++){
		fscanf(fin,"%ld%ld%ld",&oper,&x,&y);
		if(istrue(oper,x,y))
			switch(oper){
				case 1:	unite(x,y);	break;
				case 2:	eat(x,y);
			}
		else lie_sum++;
	}
	fprintf(fout,"%ld\n",lie_sum);
	fclose(fin),fclose(fout);
	return 0;
}

下面是另外一种解法，同样使用了并查集。这是我在思考Parity Game时得到启发想出来的。我们上面处理三种动物关系时是通过处理各类动物组成的集合之间的关系来进行的。这种方法的实质其实是并查集“套”并查集。这种方法在关系较为简单时还有效，但如果关系较复杂呢？显然会因过于复杂而力不从心。

这就需要我下面要说的这种方法了。

其实很简单。只要稍稍变换一下思路就行了。我们避免处理集合间的关系，而是把它处理成集合内部的问题。我们把所有发生关系的动物看成一个集合，它们不需要是同类的。因为我们知道，这样形成的整个集合中各个动物间的关系都是密切相关的，任何一个动物身份的确定都会使得整个集合确定下来。我们为了维持这种关系，只需维护每个动物与其父节点之间的捕食关系就行了(通过简单维护一个p_r域实现)。而任意两个在同一集合中的动物都可以通过根节点联系起来。路径压缩也很好实现。当两个动物发生关系时，我们只需要合并两个集合就可以处理所有的关系了。就这么简单。

时空开销（都比第一种方法小）：

代码：

//#define NDEBUG
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cassert>
using namespace std;
const long max_n = 50000;
long N,K,lie_sum;
struct set_elem{
	long p,rank;
	long p_r;//the relationship between the node and its father
	//1 means equal, 2 mean it eat it's father,
	//3 means its father eats it
}set[max_n];
long Find(long x,long &ch_r){
	if(set[x].p!=x){
		set[x].p=Find(set[x].p,set[x].p_r);
		if(ch_r==1)	ch_r=set[x].p_r;
		else if(ch_r!=set[x].p_r) ch_r=1;
		else ch_r=(ch_r==2?3:2);
	}
	return set[x].p;
}
void Union(long oper,long x,long y){
	//we should be sure that x and y are not in one same set
	assert(oper==1||oper==2||oper==3);
	y=Find(y,oper);
	if(oper!=1) oper=(oper==2?3:2);
	x=Find(x,oper);
	assert(x!=y);
	if(set[x].rank>set[y].rank){
		set[y].p=x;
		set[y].p_r=oper;
	}else{
		set[x].p=y;
		if(oper!=1) oper=(oper==2?3:2);
		set[x].p_r=oper;
		if(set[x].rank==set[y].rank) set[y].rank++;
	}

}
int main(){
	FILE *fin = fopen("eat.in","r"),*fout = fopen("eat.out","w");
	fscanf(fin,"%ld%ld",&N,&K);
	for(int i=1;i<=N;i++)	set[i].p=i; //initialize the set
	for(long i=1,oper,x,y,tmp;i<=K;i++){
		fscanf(fin,"%ld%ld%ld",&oper,&x,&y);
		if(x>N||y>N){
			//cout << i << endl;
			lie_sum++;
			continue;
		}
		tmp=1;Find(y,tmp);
		tmp=1;Find(x,tmp);
		if(set[x].p!=set[y].p) Union(oper,x,y);
		else if(oper==1&&set[x].p_r==set[y].p_r) continue;
		else if(oper==2&&
              (set[x].p_r==2&&set[y].p_r==1||
               set[x].p_r==1&&set[y].p_r==3||
               set[x].p_r==3&&set[y].p_r==2)
             ) continue;
		else {
			//cout << i << endl;
			lie_sum++;
		}
		/*
		if(istrue(oper,x,y))	Union(short(oper),x,y);
		else lie_sum++;
		*/
	}
	fprintf(fout,"%ld\n",lie_sum);
	fclose(fin),fclose(fout);
	system("pause");
	return 0;
}

可能你对下面的文章也感兴趣：

1. [URAL1028]Stars (Using SBT, SBST, VBST)
2. Size Balanced Tree in C++
3. [IOI 01] Mobile Phones

There are n points given in a space. There are no three points, such that they lie on the same straight line. Each pair of points is connected by a segment coloured red or black. Each triangle, whose sides have the same colour is called a monochromatic triangle. We are given a list of all red segments and we want to find the number of all monochromatic triangles.

Task

• reads from the text file TRO.IN the following data: the number of points, the number of red segments and their list,
• finds the number of monochromatic triangles,
• writes the result to the text file TRO.OUT.

Input

In the second line of the same file there is one integer m, 0 <= m <= 250000, which equals the number of red segments.

In each of the following m lines there are two integers p and k separated by a single space, 1 <= p < k <= n. They are numbers of vertices which are ends of a red segment.

Output

Example

 6  9 1 2 2 3 2 5 1 4 1 6 3 4 4 5 5 6 3 6

 2

Solution

按照ghost的建议开始看一些组合数学的东西了，挺难但是也很有趣啊~

这道经典题就作为我做这类题目的开始吧。

#include <cstdio>
using namespace std;
int main(){
	FILE *fin = fopen("TRO.IN","r"),*fout = fopen("TRO.OUT","w");
	long n,//the number of points
		m,//the number of red segments
		red[1001]={0},//the number of red segments connected to each point
		mono_sum=0;//the sum of monochromatic triangles
	fscanf(fin,"%ld%ld",&n,&m);
	mono_sum=(n-2)*(n-1)*n/6;
	for(long p,k;m>0;m--,red[p]++,red[k]++)	fscanf(fin,"%ld%ld",&p,&k);
	for(int i=1;i<=n;i++)	mono_sum-=(red[i]*(n-red[i]-1)/2);
	fprintf(fout,"%ld\n",mono_sum);
	fclose(fin);fclose(fout);
	return 0;
}

可能你对下面的文章也感兴趣：

1. [ZOJ1610]Count the Colors
2. [URAL1028]Stars (Using SBT, SBST, VBST)
3. [POI VII] Promotion

Great Bytelandish net of supermarkets asked you for writing a program simulating costs of the promotion being prepared.

The promotion has to obey the following rules:

• A customer, who wants to participate in the promotion, writes on the bill, paid by himself, his personal details and throws it to a special ballot box.
• At the end of every day of the promotion, two bills are taken out from the ballot box:
  • the first bill amounting to the greatest sum is chosen,
  • then the bill amounting to the least sum is chosen;

  The customer, who has paid the greatest bill, gets a money prize equal to the difference between the sum on his bill and the sum on the bill amounting to the least sum.

• To avoid multiple prizes for one purchase, both bills selected accordingly to the above rules, do not return to the ballot box, but all remaining bills still participate in promotion.

Turnovers of the supermarket are very big, thus an assumption can be made, that at the end of every day, before taking out bills amounting to the greatest and the least sum, there are at least 2 bills in the ballot box.

Your task is to compute on the basis of information about prices on bills thrown to the ballot box on each day of promotion, what will be the total cost of prizes during the whole promotion.

Task

Write a program, which:

• reads from the text file PRO.IN a list of prices on bills thrown to the ballot box on each day of the promotion,
• computes the total cost of prizes paid in consecutive days of promotion,
• writes the result to the text file PRO.OUT.

Input

The first line of the text file PRO.IN contains one positive integer n, where 1 <= n <= 5000, which is the duration of promotion in days.

Each of the next n lines consists of a sequence of non-negative integers separated by single spaces. Numbers in the (i+1)-th line of the file represent prices on bills thrown to the ballot box on the i-th day of promotion. The first integer in the line is k, 0 <= k <= 10^5, the number of bills from the day, and the next k numbers are positive integers standing for the prices on bills; none of these numbers is greater than 10^6.

The total number of bills thrown to the ballot box during the whole promotion does not exceed 10^6.

Output

The text file PRO.OUT should contain exactly one integer, which is equal to the total cost of prizes paid during the whole promotion.

Example

 5 3 1 2 3 2 1 1 4 10 5 5 1 0 1 2

 the correct answer is the output file PRO.OUT 

 19

Solution

这是一个坑，为了催促我快点搞定这题……这破题已经搞了好几天了，已经写了5个版本，用了sbt、静态bst、堆，现在正在调试的是第6个版本，应该也是最后一个版本了……我的效率太低，太低……

没心再写了，反正最后已经不TLE了……

写了7遍还是没写过Ghost……但是还是学到了不少东西的。这题本来是出现在一个线段树论文中作为例题的，我就想，用bst不是更方便么。然后就写了个SBT，稍微改进了下Delete过程，然后就出现了1号夸张的结果。Ghost写了个treap比我快n多，发现原来是因为他合并了相同的节点。改进后效果非常明显，得到了2号代码。但是仍然不够快，就写了3号的静态BST，应该和线段树的速度差不多的，但仍然不够快。说明那个论文里说用线段树解是扯的……

CQF大牛说要用堆解这题。Ghost牛解释说要同时维护一个大根堆和一个小根堆，并通过维护指针来实现在从一个堆中取出最值后能在另一个堆中同时移除这个值。这样就可以同时支持取最大和最小了。据此我写出了4号代码。下面我解释下维护过程：

首先对指针的维护要确保对于一个堆中的节点能直接找到另一个堆中具有相同关键字的节点，它的实现其实很方便，这里就不说了。每次插入一个节点时，只要在每个堆中都像普通堆一样进行维护就行了，只是同时要维护指针而已。而取最值也不麻烦。比如要取最大值，对于大根堆的维护只是和平常一样就行了。至于小根堆，由于我们取走的是最大值，那它一定小于等于小根堆的最后一个节点，这样我们只要用减小小根堆中某节点值的方法来维护它就行了。取最小值则与此对称。这样我就写出了5号代码。

但还是不够快。Ghost的一个优化又是合并相同节点。由于数据范围不大，又都是整数而无需离散化，那直接就可以通过稍微修改一下指针域并加上计数域count来支持O(1)查找和计数修改。这样就得到了6号代码。可见合并相同节点是BST、Heap等ds中一种很有效的优化手段。它可以降低树的高度，减少节点数目，从而减少旋转次数、heapify次数等等。

剩下的就是纯粹的代码优化了。始终搞不过Ghost，郁闷……

代码不帖了。

可能你对下面的文章也感兴趣：

1. [USACO]Mixing Milk
2. [URAL1028]Stars (Using SBT, SBST, VBST)
3. [ZOJ1610]Count the Colors

Mobile phones

PROBLEM

Suppose that the fourth generation mobile phone base stations in the Tampere area operate as follows. The area is divided into squares. The squares form an S´S matrix with the rows and columns numbered from 0 to S-1. Each square contains a base station. The number of active mobile phones inside a square can change because a phone is moved from a square to another or a phone is switched on or off. At times, each base station reports the change in the number of active phones to the main base station along with the row and the column of the matrix.

Write a program, which receives these reports and answers queries about the current total number of active mobile phones in any rectangle-shaped area.

INPUT AND OUTPUT

The input is read from standard input as integers and the answers to the queries are written to standard output as integers. The input is encoded as follows. Each input comes on a separate line, and consists of one instruction integer and a number of parameter integers according to the following table.

CONSTRAINTS

Out of the 20 inputs, 16 are such that the table size is at most 512×512.

NOTE: The web test facility feeds your input file to your program’s standard input.

SOLUTION

挺经典的一道数据结构。简单模拟肯定会挂，估计过一两个，但没试过；如果只对x维护二分树结构（我第一次就是这么做的），时间复杂度为O(nlogn)，能过6个点；只有对x和y都维护二分树结构才能AC。很郁闷的是我用的虚BST又比标程的树状数组慢。我的时间消耗（这个评测系统ms不支持卡空间）：

Problem: F:\My Documents\My CPP Files\Other\mobile\test\data\mobile.ini
mobiles_1.in = 5.0 (0.02s)
mobiles_2.in = 5.0 (0.03s)
mobiles_3.in = 5.0 (0.02s)
mobiles_4.in = 5.0 (0.09s)
mobiles_5.in = 5.0 (0.25s)
mobiles_6.in = 5.0 (0.14s)
mobiles_7.in = 5.0 (0.28s)
mobiles_8.in = 5.0 (0.41s)
mobiles_9.in = 5.0 (0.55s)
mobiles_10.in = 5.0 (0.55s)
mobiles_11.in = 5.0 (0.53s)
mobiles_12.in = 5.0 (0.56s)
mobiles_13.in = 5.0 (0.59s)
mobiles_14.in = 5.0 (0.58s)
mobiles_15.in = 5.0 (0.59s)
mobiles_16.in = 5.0 (0.59s)
mobiles_17.in = 5.0 (0.63s)
mobiles_18.in = 5.0 (0.64s)
mobiles_19.in = 5.0 (0.66s)
mobiles_20.in = 5.0 (0.67s)

Score = 100.0
TimeUsed = 8.38
AllScore = 100.0

Summary:
UserID = tomtung_modified

Score = 100.0/100.0
TimeUsed = 8.38

双重嵌套虚BST代码：

/*
PROG: mobiles
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <cstdio>
#include <algorithm>
#define FILE_IO
using namespace std;
#ifdef FILE_IO
   FILE *fin = fopen("mobiles.in","r"),
      *fout = fopen("mobiles.out","w");
#else
   FILE *fin = stdin, *fout=stdout;
#endif
long S,Less[1024][1024];
long num[1024][1024];//This array is useful when debugging,
                                         //but doesn't affect the output
void Increase(long x, long y, long A){
   long lx=0,rx=S-1,nowx;
   while(1){
      nowx=((lx+rx)>>1);
      if(x<=nowx){
         long ly=0,ry=S-1,nowy;
         while(1){
            nowy=((ly+ry)>>1);
            if(y<=nowy)   Less[nowx][nowy]+=A;
            if(y==nowy)   break;
            else if(y<nowy)   ry=nowy-1;
            else ly=nowy+1;
         }
      }
      if(x==nowx)   break;
      else if(x<nowx)   rx=nowx-1;
      else lx=nowx+1;
   }
}
long Sum(long x, long y){
   if(x<0||y<0)   return 0;
   long ans=0;
   long lx=0,rx=S-1,nowx;
   while(1){
      nowx=((lx+rx)>>1);
      if(x>=nowx){
         long ly=0,ry=S-1,nowy;
         while(1){
            nowy=((ly+ry)>>1);
            if(y>=nowy)   ans+=Less[nowx][nowy];
            if(y==nowy)   break;
            else if(y<nowy)   ry=nowy-1;
            else ly=nowy+1;
         }
      }
      if(x==nowx)   return ans;
      else if(x<nowx)   rx=nowx-1;
      else lx=nowx+1;
   }
}
/*
void output_array(void){
   cout << "nums:" << endl;
   for(int i=0;i<S;i++){
      for(int j=0;j<S;j++)
         cout << num[i][j];
      cout << endl;
   }
   cout << endl;
   /*
   cout << "less:" << endl;
   for(int i=0;i<S;i++){
      for(int j=0;j<S;j++)
         cout << Less[i][j];
      cout << endl;/
   cout << "line_sum:" << endl;
   for(int i=0;i<S;i++){
      for(int j=0;j<S;j++)
         cout << line_sum(i,j);
      cout << endl;
   }
   cout <<endl << "------------------------------------------------" << endl;
}
*/
int main()
{
   long i,p1,p2,p3,p4;
   while(1){
      fscanf(fin,"%ld ",&i);
      //cout << i << ' ';
      switch(i){
         case 0:
            fscanf(fin,"%ld\n",&S);
            //cout << S << endl;
            break;
         case 1:
            fscanf(fin,"%ld %ld %ld\n",&p1,&p2,&p3);
            //cout << p1 << ' ' << p2 << ' ' << p3 << endl;
            Increase(p1,p2,p3);
            break;
         case 2:
            fscanf(fin,"%ld %ld %ld %ld\n",&p1,&p2,&p3,&p4);
            //cout << p1 << ' ' << p2 << ' ' << p3 << ' ' << p4 << endl;
            fprintf(fout,"%ld\n",Sum(p3,p4)-Sum(p3,p2-1)-Sum(p1-1,p4)+Sum(p1-1,p2-1));
            break;
         case 3:
            goto outloop;
      }
      //cout << endl;output_array();
   }
   outloop:
   fflush (fout);
   fclose(fin);
   fclose(fout);
   return 0;
}

可能你对下面的文章也感兴趣：

1. [URAL1028]Stars (Using SBT, SBST, VBST)
2. [Uva #258] Mirror Maze
3. [POI IX] Railways

Solution

又是一道线段树。挖个坑先 ^_^

终于过了……反复不过竟然是因为数据用的太小了（unsigned short），后来改成long就AC了……一直觉得应该没问题啊，结果还是溢出了。看来像unsigned啊、short啊这种关键字还是慎用为妙。

从这个题可以学到线段树通过标记来减少不必要修改的思想——其实上一道zju的就是这样的。

代码：

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cassert>
using namespace std;
FILE *fin = fopen("kol.in","r"),
	*fout = fopen("kol.out","w");
const long A=1,B=60000;
long C,S,R;//城市数目、座位总数、请求数

struct STNode{
	long a,b,lch,rch,avail,sold;
	STNode(long _a, long _b){
		a=_a;
		b=_b;
		avail=S;
		sold=0;
		lch=rch=0;
	}
	STNode(void){}
}STree[(B-A)<<1];

void ST_Build(long a, long b){
	static unsigned i=1;
	unsigned now=i++;
	STree[now]=STNode(a,b);
	if(b-a>1){
		STree[now].lch=i;
		ST_Build(a,(a+b)>>1);
		STree[now].rch=i;
		ST_Build((a+b)>>1,b);
	}
}

void ST_Clear(long i){	//清空节点i的sold域
	if(i==0)	return;
	STree[STree[i].lch].sold+=STree[i].sold;
	STree[STree[i].rch].sold+=STree[i].sold;
	STree[i].avail-=STree[i].sold;
	STree[i].sold=0;
}
bool ST_Check(long a, long b, long s, long i){
	if(STree[i].sold>0)	ST_Clear(i);
	if(a<=STree[i].a&&STree[i].b<=b)	return (STree[i].avail>=s);
	else{
		bool flag1=true,flag2=true;
		if(a<((STree[i].a+STree[i].b)>>1))	flag1=ST_Check(a,b,s,STree[i].lch);
		if(b>((STree[i].a+STree[i].b)>>1))	flag2=ST_Check(a,b,s,STree[i].rch);
		return (flag1&&flag2);
	}
}
void ST_Delete(long a,long b, long s, long i){
	if(STree[i].sold>0)	ST_Clear(i);
	if(a<=STree[i].a&&STree[i].b<=b){
		assert(STree[i].avail>=s);
		STree[i].avail-=s;
		STree[STree[i].lch].sold+=s;
		STree[STree[i].rch].sold+=s;
	}else{
		if(a<((STree[i].a+STree[i].b)>>1))	ST_Delete(a,b,s,STree[i].lch);
		else	ST_Clear(STree[i].lch);
		if(b>((STree[i].a+STree[i].b)>>1))	ST_Delete(a,b,s,STree[i].rch);
		else	ST_Clear(STree[i].rch);
		STree[i].avail=min(STree[STree[i].lch].avail,STree[STree[i].rch].avail);
	}
}

int main()
{
	fscanf(fin,"%d %d %d\n",&C,&S,&R);
	ST_Build(A,B);
	for(int r=0,o,d,n;r<R;r++){
		fscanf(fin,"%d %d %d\n",&o,&d,&n);
		if(ST_Check(o,d,n,1)){
			fprintf(fout,"T\n");
			ST_Delete(o,d,n,1);
		}else	fprintf(fout,"N\n");
	}
	fclose(fin);
	fclose(fout);
	return 0;
}

P.S.不知道是不是我rp用完了，反正现在cena也不给我好好干活了。只要测pas的程序一律显示“崩溃（访问无效内存）”，重装cena、fp都没用，郁闷。就搞了两个评测系统，一个是HWD的，感觉很烦琐，不知道怎么评测C的程序；一个就是这个雅礼ZYF的系统，直接评测exe，好像不支持交互。下面是此程序生成的成绩单，我比标程慢……

成绩单

编号： standard； 总得分： 130； 总耗时： 1.21

试题名称： Problem A； 测试例数： 13； 本题得分： 130.0； 本题耗时： 1.21

例号	用时	评测结果	得分
1	0.02	正确	10
2	0.02	正确	10
3	0.02	正确	10
4	0.02	正确	10
5	0.02	正确	10
6	0.36	正确	10
7	0.03	正确	10
8	0.08	正确	10
9	0.02	正确	10
10	0.09	正确	10
11	0.11	正确	10
12	0.03	正确	10
13	0.39	正确	10

---

编号： tomtung； 总得分： 130； 总耗时： 1.61

试题名称： Problem A； 测试例数： 13； 本题得分： 130.0； 本题耗时： 1.61

例号	用时	评测结果	得分
1	0.03	正确	10
2	0.03	正确	10
3	0.03	正确	10
4	0.03	正确	10
5	0.03	正确	10
6	0.44	正确	10
7	0.05	正确	10
8	0.09	正确	10
9	0.09	正确	10
10	0.09	正确	10
11	0.16	正确	10
12	0.06	正确	10
13	0.48	正确	10

可能你对下面的文章也感兴趣：

1. [ZOJ1610]Count the Colors
2. [URAL1028]Stars (Using SBT, SBST, VBST)
3. Size Balanced Tree in C++

Count the Colors

Time limit: 1 Seconds   Memory limit: 32768K
Total Submit: 2977   Accepted Submit: 1000

Your task is counting the segments of different colors you can see at last.

Input

The first line of each data set contains exactly one integer n, 1 <= n <= 8000, equal to the number of colored segments.

Each of the following n lines consists of exactly 3 nonnegative integers separated by single spaces:

x1 x2 c

x1 and x2 indicate the left endpoint and right endpoint of the segment, c indicates the color of the segment.

All the numbers are in the range [0, 8000], and they are all integers.

Input may contain several data set, process to the end of file.

Output

Each line of the output should contain a color index that can be seen from the top, following the count of the segments of this color, they should be printed according to the color index.

If some color can’t be seen, you shouldn’t print it.

Print a blank line after every dataset.

Author: Standlove

Source: ZOJ Monthly, May 2003

Solution:

第一个用线段树过的题目啊~~呵呵。基础题目，虽然对我来说并不简单。在处理最后数线段条数的问题上颇费了些周折，先是问大牛，结果没搞懂，就自力更生地写出来了。。。

话说特别巧，我刚好是第1000个过这道题的人，哈哈

我的时空消耗：

代码（发现我越来越不爱写注释了）：

#include <cstdio>
#include <cassert>
#include <cstring>
#define NDEBUG
//#define FILE_IO
using namespace std;
#ifdef FILE_IO
	FILE *fin = fopen("INPUT.TXT","r");
	FILE *fout= fopen("OUTPUT.TXT","w");
#else
	FILE *fin = stdin;
	FILE *fout= stdout;
#endif
const unsigned short min_a=0, max_b=8000;
unsigned short N;
struct STNode{
	unsigned short a,b,lch,rch;
	short color;	//-1为无色，-2为杂色
	STNode(unsigned short __a, unsigned short __b){
		a=__a;
		b=__b;
		color=-1;
		lch=rch=0;
	}
	STNode(void){;}
};
STNode STree[(max_b-min_a)*2];
unsigned short i;
void ST_Build(unsigned short a, unsigned short b){
	unsigned now=i++;
	STree[now]=STNode(a,b);
	if(b-a>1){
		STree[now].lch=i;
		ST_Build(a,(a+b)>>1);
		STree[now].rch=i;
		ST_Build((a+b)>>1,b);
	}
}
void ST_Insert(unsigned short i,unsigned short a, unsigned short b, short color){
	assert(a<b);
	if(STree[i].color==color)	return;
	if(a<=STree[i].a&&STree[i].b<=b)	STree[i].color=color;
	else{
		if(STree[i].color!=-2&&STree[i].color!=-1){
			STree[STree[i].lch].color=STree[i].color;
			STree[STree[i].rch].color=STree[i].color;
		}
		STree[i].color=-2;
		unsigned short m=((STree[i].a+STree[i].b)>>1);
		if(a<m)	ST_Insert(STree[i].lch,a,b,color);
		if(b>m)	ST_Insert(STree[i].rch,a,b,color);
	}
}
unsigned colors[8001];
void SgCount(unsigned short i, short &a_color, short &b_color){
	//在在color中增加以i节点为根的ST中各色的线段数目
	//并返回最左、最右端的颜色分别为a_color和b_color
	if(STree[i].color!=-2){
		a_color=b_color=STree[i].color;
		if(STree[i].color!=-1)	colors[STree[i].color]++;
	}
	else{
		short m1_color,m2_color;
		SgCount(STree[i].lch,a_color,m1_color);
		SgCount(STree[i].rch,m2_color,b_color);
		if(m1_color==m2_color&&m1_color!=-1)
			colors[m1_color]--;
	}
}
int main()
{
	while(fscanf(fin,"%d\n",&N)==1){
		i=1;
		ST_Build(min_a,max_b);
		for(int i=0,a,b,color;i<N;i++){
			fscanf(fin,"%d %d %d\n",&a,&b,&color);
			ST_Insert(1,a,b,color);
		}
		memset(colors,'\0',sizeof(colors));
		short a_color,b_color;
		SgCount(1,a_color,b_color);
		for(int i=0;i<=8000;i++)
			if(colors[i]!=0)	fprintf(fout,"%d %d\n",i,colors[i]);
		fprintf(fout,"\n");
	}
	return 0;
}

可能你对下面的文章也感兴趣：

1. [URAL1028]Stars (Using SBT, SBST, VBST)
2. [01ACM NEEuropean][URAL1183]Brackets sequence
3. [USACO]Ordered Fractions

1028. Stars

Time Limit: 0.25 second
Memory Limit: 16 MB

Astronomers often examine star maps where stars are represented by points on a plane and each star has Cartesian coordinates. Let the level of a star be an amount of the stars that are not higher and not to the right of the given star. Astronomers want to know the distribution of the levels of the stars.

For example, look at the map shown on the figure above. Level of the star number 5 is equal to 3 (it’s formed by three stars with a numbers 1, 2 and 4). And the levels of the stars numbered by 2 and 4 are 1. At this map there are only one star of the level 0, two stars of the level 1, one star of the level 2, and one star of the level 3.

You are to write a program that will count the amounts of the stars of each level on a given map.

Input

The first line of the input contains a number of stars N (1 ≤ N ≤ 15000). The following N lines describe coordinates of stars (two integers X and Y per line separated by a space, 0 ≤ X,Y ≤ 32000). There can be only one star at one point of the plane. Stars are listed in ascending order of Y coordinate. Stars with equal Y coordinates are listed in ascending order of X coordinate.

Output

The output should contain N lines, one number per line. The first line contains amount of stars of the level 0, the second does amount of stars of the level 1 and so on, the last line contains amount of stars of the level N

Solution

挺不错的一道用来练DS的题：很多DS都能用。我这里用了SBT(Size Balanced Tree)、静态BST和虚BST。树状数组也可以做，但是我不会~~~ 本来看好多人都说用线段树的也想试试，但是发现ST写起来无论在时空消耗还是编程复杂度上都没有优势……莫非是我搞垃圾了？哪位帮忙放个ST让我瞻仰下，多谢……

下面是代码。没有做速度的比较，因为没有可比性：SBT用了动态储存，VBST用了排序，SBST则是直接建树。这样速度无法体现DS的优劣，比较就没有必要了。

SBT版（与普通SBT不同，旋转和插入都需要维护less）：

/*
  Name: URAL#1028. Stars
  Author: 巨菜逆铭(Tom Tung)
  Date: 20-06-07 16:50
  Description: Using Size Balanced Tree
*/
#include <cstdlib>
#include <cstdio>
#include <cassert>
#define NDEBUG
#ifndef NDEBUG
  FILE *fin=fopen("INPUT.TXT","r");
  FILE *fout=fopen("OUTPUT.TXT","w");
#else
  FILE *fin=stdin;
  FILE *fout=stdout;
#endif
using namespace std;
struct SBTNode{
	SBTNode *ch[2];
	long key;
	unsigned long size,less;
	SBTNode(long _key,unsigned long _size);
}NIL=SBTNode(0,0);
typedef SBTNode *SBTree;
SBTNode::SBTNode(long _key,unsigned long _size=1){
	ch[0]=ch[1]=&NIL;
	size=_size;
	key=_key;
	less=1;
}
inline void SBT_Rotate(SBTree &x, bool flag){
	SBTNode *y=x->ch[!flag];
	assert(y!=&NIL&&x!=&NIL);
	x->ch[!flag]=y->ch[flag];
	y->ch[flag]=x;
	y->size=x->size;
	x->size=x->ch[0]->size+x->ch[1]->size+1;
	if(!flag)	y->less+=x->less;
	else	x->less-=y->less;
	assert(x->less>0);
	x=y;
}
void SBT_Maintain(SBTree &T,bool flag){
	if(T->ch[flag]->ch[flag]->size>T->ch[!flag]->size)
		SBT_Rotate(T,!flag);
	else if(T->ch[flag]->ch[!flag]->size>T->ch[!flag]->size){
		SBT_Rotate(T->ch[flag],flag);
		SBT_Rotate(T,!flag);
	}
	else return;
	SBT_Maintain(T->ch[0],0);
	SBT_Maintain(T->ch[1],1);
	SBT_Maintain(T,0);
	SBT_Maintain(T,1);
}

unsigned lev;
void SBT_Insert(SBTree &T, long key){
	if(T==&NIL){
		T=new SBTNode(key);
		return;
	}
	if(key>=T->key)	lev+=(T->less);
	if(key<=T->key)	T->less++;
	if(key==T->key)	return;
	T->size++;
	SBT_Insert(T->ch[key>T->key],key);
	assert(lev<15000);
	SBT_Maintain(T,key>T->key);
}

int main(){
	unsigned N=0,level[15000]={0};
	SBTree T=&NIL;
	fscanf(fin,"%u",&N);
	for(int i=1,x,y;i<=N;i++){
		fscanf(fin,"%u%u",&x,&y);
		lev=0;
		SBT_Insert(T,x);
		level[lev]++;
	}
	for(int i=0;i<N;i++)	fprintf(fout,"%d\n",level[i]);
	fclose(fin);
	fclose(fout);
	return 0;
}

VBST版：

/*
  Name: URAL#1028. Stars
  Author: 巨菜逆铭(Tom Tung)
  Date: 20-06-07 13:55
  Description: Using Virtual Binary Search Tree
*/
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define NDEBUG
#ifndef NDEBUG
  FILE *fin=fopen("INPUT.TXT","r");
  FILE *fout=fopen("OUTPUT.TXT","w");
#else
  FILE *fin=stdin;
  FILE *fout=stdout;
#endif
using namespace std;
unsigned N,x[15001],y,T[15001],LESS[15001],level[15000];
int cmp(const void *a, const void *b){return *(int*)a-*(int*)b;}
void Ins(unsigned xi){
	unsigned l=1,r=N,lev=0,m;
	while(l<r){
		m=(l+r)/2;
		if(T[m]<=xi)	lev+=LESS[m];
		if(xi<=T[m])	LESS[m]++;
		if(xi==T[m])	break;
		else if(xi<T[m])	r=m-1;
		else	l=m+1;
	}
	level[lev]++;
}
int main(){
	fscanf(fin,"%u",&N);
	for(int i=1;i<=N;i++)	fscanf(fin,"%u%u",&x[i],&y);
	memcpy(T,x,sizeof(x));
	qsort(T+1,N,sizeof(T[1]),cmp);
	for(int i=1;i<=N;i++)	Ins(x[i]);
	for(int i=0;i<N;i++)	fprintf(fout,"%d\n",level[i]);
	fclose(fin);
	fclose(fout);
	return 0;
}

SBST版：

/*
  Name: URAL#1028. Stars
  Author: 巨菜逆铭(Tom Tung)
  Date: 20-06-07 17:20
  Description: Using Static Binary Search Tree
*/
#include <cstdlib>
#include <cstdio>
#include <cassert>
#define NDEBUG
#ifndef NDEBUG
  FILE *fin=fopen("INPUT.TXT","r");
  FILE *fout=fopen("OUTPUT.TXT","w");
#else
  FILE *fin=stdin;
  FILE *fout=stdout;
#endif
using namespace std;
unsigned N,SBSTree[32002],LESS[32002],level[15000];
void SBST_Build(unsigned int k){
	if(k>32001)	return;
	static unsigned p=0;
	SBST_Build(k<<1);
	SBSTree[k]=p++;
	SBST_Build((k<<1)+1);
}
void SBST_Insert(unsigned x)
{
	unsigned now=1,lev=0;
	while(1){
		if(SBSTree[now]<=x)	lev+=LESS[now];
		if(x<=SBSTree[now])	LESS[now]++;
		if(SBSTree[now]>x)	now<<=1;
		else if(SBSTree[now]<x)	(now<<=1)++;
		else break;
	}
	level[lev]++;
}
int main()
{
	SBST_Build(1);
	fscanf(fin,"%u",&N);
	for(unsigned i=1,x,y;i<=N;i++){
		fscanf(fin,"%u%u",&x,&y);
		SBST_Insert(x);
	}
	for(int i=0;i<N;i++)	fprintf(fout,"%d\n",level[i]);
	fclose(fin);
	fclose(fout);
	return 0;
}

可能你对下面的文章也感兴趣：

1. Size Balanced Tree in C++
2. [NOI99]棋盘分割(Chessboard Division)
3. [01ACM NEEuropean][URAL1183]Brackets sequence

#include <iostream>
#include <cassert>
#include <cstring>
using namespace std;
int M,N;
char map[51][51];
int mirror_sum;//镜子的个数
int mirror_num[51][51];//[x][y]:(x,y)处镜子的编号；出/入口为-1
struct Mirror{
	short neighbor[4];	//4个方向上的相邻镜子编号：0为不存在，-1为出/入口
	//关于方向的定义：0上，1左，2下，3右
	short x,y;//镜子坐标
}mirror[2500];
bool state[2500];//[i]:第[i]面镜子的状态：0为'/'，1为'\'

bool used[2500];
//used[i]:dfs中记录第i个镜子是否原来已经使用（即镜子能否翻转而不影响已知的光线路径？）
inline void get_next(int i,int j,int &next_i,int &next_j)
//dfs调用的子过程，根据当前镜子编号和入射方向确定下一面镜子的编号和入射方向
{
	int d[4];
	if(state[i]==0)//下-右，上-左
	{
		d[0]=1;d[1]=0;d[2]=3;d[3]=2;
	}
	else{	//上-右，下-左
		d[0]=3;d[1]=2;d[2]=1;d[3]=0;
	}
	next_j=(d[j]+2)%4;
	next_i=mirror[i].neighbor[d[j]];
}
bool dfs(int i, int j)	//射向第i面镜子，入射方向为j。若找到解则返回true
{
	if(i==-1)	return true;	//到达出口
	int next_i,next_j;
	bool used_i=used[i],flag=false;
	used[i]=true;
	get_next(i,j,next_i,next_j);
	if(next_i!=0)
		flag=dfs(next_i,next_j);
	if(flag)	return true;
	if(!used_i)
	{
		state[i]=!state[i];
		get_next(i,j,next_i,next_j);
		flag=dfs(next_i,next_j);
		if(flag)	return true;
		state[i]=!state[i];
	}
	used[i]=used_i;
	return false;
}

int main()
{
	int counter=0;
	while(1)
	{
		cin >> M >> N;
		if(M==-1&&N==-1)	break;	//判断输入结束
		if(counter++>0)	cout << endl;
		/*初始化*/
		mirror_sum=0;
		memset(mirror_num,'\0',sizeof(mirror_num));
		memset(mirror,'\0',sizeof(mirror));
		memset(used,'\0',sizeof(used));
		memset(state,'\0',sizeof(state));

		//读入数据
		for(int x=1;x<=N;x++)
			for(int y=1;y<=M;y++)
			{
				cin >> map[x][y];
				if(map[x][y]=='/'||map[x][y]=='\\')	//记录镜子的信息
				{
					mirror_sum++;
					mirror_num[x][y]=mirror_sum;
					mirror[mirror_sum].x=x;
					mirror[mirror_sum].y=y;
					state[mirror_sum]=(map[x][y]=='\\');
				}
				else if((x==N||y==M||x==1||y==1)&&map[x][y]=='.')	//记录出/入口的信息
					mirror_num[x][y]=-1;
			}

		//处理各镜子的相邻镜子信息
		const int dir_x[4]={-1,0,1,0},dir_y[4]={0,-1,0,1};
		int first_mirror=-1,first_dir=-1;
		for(int i=1,x,y;i<=mirror_sum;i++)
			for(int d=0;d<=3;d++)
			{
				if(mirror[i].neighbor[d]!=0)	continue;
				x=mirror[i].x,y=mirror[i].y;
				while(1)
				{
					x+=dir_x[d];
					y+=dir_y[d];
					assert(x>=1&&x<=N&&y>=1&&y<=M);
					if(map[x][y]=='*')	break;	//遇到黑洞
					if(mirror_num[x][y]==-1)	//遇到出/入口
					{
						mirror[i].neighbor[d]=-1;
						first_mirror=i;
						first_dir=d;
						break;
					}
					if(mirror_num[x][y]>0)	//遇到镜子
					{
						mirror[i].neighbor[d]=mirror_num[x][y];
						mirror[mirror_num[x][y]].neighbor[(d+2)%4]=i;
						break;
					}
				}
			}

		if(first_mirror!=-1&&first_dir!=-1)
		{
			bool flag=dfs(first_mirror,first_dir);//搜索可行解
			assert(flag);
		}

		for(int i=1;i<=N;i++)//输出可行解
		{
			for(int j=1;j<=M;j++)
				if(mirror_num[i][j]==0||mirror_num[i][j]==-1)	cout << map[i][j];
				else cout << (state[mirror_num[i][j]]?'\\':'/');
			cout << endl;
		}
	}
	return 0;
}

可能你对下面的文章也感兴趣：

1. [01ACM NEEuropean][URAL1183]Brackets sequence
2. [IOI2000国家队原创题] 艺术馆的火灾
3. [POI VI Stage 1 Problem 1] Musketeers

Brackets sequence

Time Limit: 1.0 second

Memory Limit: 16 MB

Let us define a regular brackets sequence in the following way:

1. Empty sequence is a regular sequence.
2. If S is a regular sequence, then (S) and [S] are both regular sequences.
3. If A and B are regular sequences, then AB is a regular sequence.

For example, all of the following sequences of characters are regular brackets sequences:

(), [], (()), ([]), ()[], ()[()]

And all of the following character sequences are not:

(, [, ), )(, ([)], ([(]

Some sequence of characters ‘(‘, ‘)’, ‘[', and ']‘ is given. You are to find the shortest possible regular brackets sequence, that contains the given character sequence as a subsequence. Here, a string a₁a₂…a_n is called a subsequence of the string b₁b₂…b_m, if there exist such indices 1 ≤ i₁ < i₂ < … < i_n ≤ m, that a_j=b_ij for all 1 ≤ j ≤ n.

Input

The input file contains at most 100 brackets (characters ‘(‘, ‘)’, ‘[' and ']‘) that are situated on a single line without any other characters among them.

Output

Write to the output file a single line that contains some regular brackets sequence that has the minimal possible length and contains the given sequence as a subsequence.

Sample

Problem Author: Andrew Stankevich
Problem Source: 2001-2002 ACM Northeastern European Regional Programming Contest

Solution

终于过了这题……WA了两次。第一次是判断括号匹配的栈写错了，WA#9；第二次是没有考虑输入文件是空串的情况，WA#13并持续一周 -_-|||

而且这次也写垃圾了，长达80多行。好像原来的ural的内存限制是1000K？这样说我开一个100*100的string数组真是件奢侈的事情呢……

#include <iostream>
#include <fstream>
#include <string>
#include <cassert>
using namespace std;
ifstream fin("bracket.in");
ofstream fout("bracket.out");
string S;
inline bool isregular(int i,int j)	//判断原串中的子串S[i...j]是否规则
{
	if(j<i)	return true;
	else if(j==i)	return false;
	char stack[100];	int p=0;
	for(int k=i;k<=j;k++)
	{
		if(p==0)
		{
			if(S[k]=='('||S[k]=='[')	stack[p++]=S[k];
			else return false;
		}
		else{
			if(( stack[p-1]=='('&&S[k]==')' )||( stack[p-1]=='['&&S[k]==']' ))	p--;
			else if(S[k]==')'||S[k]==']')	return false;
			else	stack[p++]=S[k];
		}
	}
	return (p==0);
}
string s[100][100];	//[i][j]：按照最少原则添加括号规则化S[i...j]后得到的串
string memo(int i, int j)	//记忆化搜索
{
	if(s[i][j]!="")	return s[i][j];
	if(isregular(i,j))	//若S[i...j]本身就已经是规则的
	{
		s[i][j].assign(S,i,j-i+1);
		return s[i][j];
	}
	if(i==j)	//若当前串仅由一个字符组成
	{
		if(S[i]=='('||S[i]==')')	s[i][j]="()";
		else if(S[i]=='['||S[i]==']')	s[i][j]="[]";
		else assert(0);
		return s[i][j];
	}
	string ans,tmp,tmp2;
	unsigned size=UINT_MAX;
	if(( S[i]=='('&&S[j]==')' )||( S[i]=='['&&S[j]==']' ))	//若S[i...j]首尾配对，则只需使S[i+1...j-1]规则就得到一个解
	{
		ans=S[i]+memo(i+1,j-1)+S[j];
		size=ans.size();
	}
	else if(( S[i]=='('&&S[j]!=')' )||( S[i]=='['&&S[j]!=']' ))	//S[i...j]首尾不配对，与以上类似
	{
		ans=S[i]+memo(i+1,j);
		if(S[i]=='(')	ans=ans+')';
		else if(S[i]=='[')	ans=ans+']';
		else assert(0);
		size=ans.size();
	}
	else if(( S[i]!='('&&S[j]==')' )||( S[i]!='['&&S[j]==']' ))
	{
		ans=memo(i,j-1)+S[j];
		if(S[j]==')')	ans='('+ans;
		else if(S[j]==']')	ans='['+ans;
		else assert(0);
		size=ans.size();
	}
	for(int k=i;k<j;k++)	//规则化S[i...k]和S[k+1...j]后合并得到的串
		if(size>memo(i,k).size()+memo(k+1,j).size())
		{
			ans=memo(i,k)+memo(k+1,j);
			size=memo(i,k).size()+memo(k+1,j).size();
		}
	return (s[i][j]=ans);
}
int main()
{
	fin >> S;
	if(S.size()==0)
	{
		fout << endl;
		return 0;
	}
	fout << memo(0,S.size()-1) << endl;
	return 0;
}

可能你对下面的文章也感兴趣：

1. [NOI99]棋盘分割(Chessboard Division)
2. [USACO]Arithmetic Progressions
3. [NOI97]积木游戏(Game)

艺术馆的火灾

Fire of the Art Gallery

IOI2000 National Training Team Originals

Author: 张辰

背景描述

这幢古老的建筑是一个艺术馆，它珍藏着上百件绘画、雕塑以及其他艺术品，就连建筑本身也是一件艺术。但是，岁月并不在乎它的精致与美丽，时光在渐渐剥夺着这幢木屋的生命。终于，在一个月色昏暗的夜晚，它着火了。

艺术馆是一幢两层的小楼，每一层有N个房间，每个房间中收藏的艺术品的价值都可以用一个正整数来表示。下面是一个N=4的例子。

在这个例子中，二层楼的第四个房间中艺术品的价值最大，为60。而一层楼的第四个房间中艺术品的价值仅为20。

在消防队员火速赶到的时候，火势已经蔓延了整个建筑，消防队员们观察每个房间中的火势，将它们分别用一个正整数来表示。在上面的例子中，各房间中的火势可能如下。

你可以看到，二层楼的第四个房间中火势最强，为70。而一层楼的第三个房间中火势较弱，为20。

由于火情紧急，消防队员们准备使用一种新型的灭火器。这种灭火器只能发射K次，每次发射将覆盖一个矩形的区域（矩形的高度可以是1也可以是2）。它的威力巨大，所到之处不但火焰会被扑灭，就连同在一处的艺术品也难以幸免。因此，如何善用这种灭火器成了最大的问题。

一个例子：如果灭火器的一次发射覆盖了下图阴影所示的2×2矩形区域，那么这四个房间的火势和艺术品价值都将成为0。

任务说明

给出艺术馆每层的房间数N和灭火器的发射次数K，以及每个房间中艺术品的价值和火势，你需要决定灭火器每次应该怎样发射（也可以不发射），才能将这次火灾的损失降到最低限度。这个损失用你所摧毁的艺术品的总价值，加上剩余的火势总值（这些火焰将需要消防队员们亲身去扑灭）来衡量。

输入数据

输入文件的第一行有两个整数N（1 <= N <= 100）、K（1 <= K <= 10），分别表示艺术馆中每层的房间数和灭火器的发射次数。

接下来的两行每行有N个整数，其中第4-i行的第j个整数V_i,j表示的是第i层第j个房间中艺术品的价值（1 <= i <= 2，1 <= j <= N，1 <= V_i,j <= 10000）。

再接下来的两行每行也有N个整数，其中第6-i行的第j个整数F_i,j表示的是第i层第j个房间中的火势（1 <= i <= 2，1 <= j <= N，1 <= F_i,j <= 10000）。

输出数据

你的输出文件应该有K行，每行有四个整数L₁、R₁、L₂、R₂，表示你的灭火器的一次行动。如果灭火器这次不发射，那么这四个整数都为0；否则这次发射所覆盖的矩形区域的左下角是第L₁层的第R₁个房间，右上角是第L₂层的第R₂个房间。

注意：你的每次发射所覆盖的矩形区域必须位于小楼之内，并且矩形的面积至少为0。即1 <= L₁ <= L₂ <= 2，1 <= R₁ <= R₂ <= N。

输入输出样例

INPUT.TXT	OUTPUT.TXT	样例图示
4 2 40 50 30 60 30 30 40 20 50 40 50 70 40 50 20 30	1 1 1 2 2 3 2 4	摧毁艺术品：30+60+30+30=150 剩余火势：50+40+20+30=140 最小损失：150+140=290

评分标准

每个测试点都有一定的时间限制。你的程序只有在规定的时限内输出解，并且按照你的方案来发射灭火器可以将损失降到最小，你才会得到相应测试点的分值；否则这个测试点不得分。

注意：本题的解不一定是唯一的。即对于一个测试数据，可能有多种发射灭火器的方案都可以使损失达到最小。在这种情况下，你只要输出最优方案中的任意一种即可。

解题报告

自己独立做出来的好有成就感啊……^_^

做这题的过程还相当传奇。话说那天生物课没拿书，直接被老师赶出去到物理办公室门口站着。岂知那里却安静、光线明亮，清风吹拂，透过窗口可以看见墙上大片翠绿的藤蔓植物在风中生起层层波浪，让人心旷神怡，真是个绝佳的自习的所在。当时手里也没书，没事干，就想起了这道本来一看来源就已经准备直接看题解的题目，和老师要了纸笔，想啊想啊就把这题搞出来了。-_-|||

不扯了，下面说说这题的做法（和官方解法不太一样~）。

这题的模型可以看成是一个2*N的矩形表格中每格存有有序数对(V,F)，现在要从表格中选出一些格子，要求：

1.（选出格子中的V）+（未选中格子中的F）值最小；

2.这些格子能组成的最少完整矩形个数不大于定值K。

在第2个要求中我们强调“最少”和“完整”的矩形，这样才能得到最优解。因此，我们可以设法求出一种满足条件的格子选择，然后再按照最少原则用贪心算法划分矩形，且规定划分得到的矩形互不相交（因为相交时得到的解一定不优于此）。以样例数据为例，先选出(1,1)，(1,2)，(2,3)，(2,4)四个格子，然后再把它们组合成(1,1,1,2)和(2,3,2,4)两个完整矩形。这已经是这四个格子所能组成的最少矩形数目了。（下文中无特殊说明，提到的“矩形”都指满足“最少”和“完整”要求的。）

由于表格的高已经确定为2这个很小的值，我们可以根据每一列的损失数来划分阶段。我们用(i,j,k)来表示一个状态。其中i表示当前状态为第i列，用于阶段划分；k表示此次决策前已经得到的矩形个数，用以在状态转移时限制矩形的个数；j表示要决策列的前一列中的灭火器使用情况，用于在状态转移时更新矩形的数目（后面我们可以看到当前列的决策是否导致新矩形的产生完全取决于前一列的灭火器使用情况）。

选择不同的递推方向会导致不同的状态定义和转移方程。这里我们选择顺推，因为每次决策都会唯一对应一个状态后继，这样转移方程写起来会简单许多。

我们的状态定义为：dp(i,j,k)表示前i列已经有k个矩形、第i列的状态为j之后还能获得的最小损失。转移方程为：dp(i,j,k)=min{dp(i+1,jj,kk)+loss(i+1,jj)}。其中jj表示决策第i+1行灭火器的使用情况。kk为因此得到的矩形数目，即若决策jj导致了矩形个数的增加，则kk=k+1，否则kk=k。loss(i,j)为第i列灭火器使用情况为j时的损失。

每一列的灭火器使用情况（j的取值）有4种：0.楼上楼下都不使用灭火器；1.楼上使用；2.楼下使用；3.上下都用。如果我们画两列格子看看，就会发现矩形数目不增加当且仅当jj=0或j==jj。这样我们就可以通过转移方程求出解dp(0,0,0)。

——但是等等！

这就是我第一次写时出现的疏忽（这让我第一次WA了4个点并调试了整整一个晚上）。我们没有注意到当j=3,jj=1（或2，这里以1为例）时可能有以下两种情况：

其中前一种如我们所想，jj决策导致了矩形数目的增加，但是后一种情况却不是这样。虽然j=3，jj=1，满足矩形数目增加的条件，但是矩形数目实际并没有增加。这是由于更早些的决策已经使第i行的上下两层分属两个矩形。因此我们需要为上下都使用的决策留出两个j值以示区别。这部分细节请看代码。

这样得到的状态定义和转移方程明显满足最有子结构和无后效性。我们可以据此求出最小损失。

这道题并不要求输出最小损失，而是要求输出灭火器每次使用的覆盖范围。这我们就需要构造最优解。我的方法很朴素。在dp过程中维护一个数组build[i][j][k]，其值为状态(i,j,k)做出的最优决策jj。dp结束后，我们就可以递归地在一个bool数组上标记出那些使用了灭火器的格子。最后用贪心（细节见代码）把它们组合成矩形输出，这样问题就解决了。

这个算法思路比较简单，编程复杂度与官方解相当。至于时空复杂度，由于我没有系统学习过相关理论，不好乱说，ms是空间复杂度比官方解高，但是时间复杂度比官方解低？

#include <iostream>
#include <fstream>
#include <cassert>
using namespace std;
ifstream fin("Input.txt");
ofstream fout("Output.txt");
int room_n,shoot_k,v[3][101],f[3][101];

/*dp(memoization)部分*/
int dp[101][5][11];//[i][j][k]:前i列已经最少有k个完整矩形、第i列的状态为j之后还能获得的最小损失
bool checked[101][5][11];
int memo(int i,int j, int k);
int loss(int i, int j);	//memo调用的子过程，返回第i行决策为j时的净损失

/*最优解的构造部分*/
int build[101][5][11];	//记录(i,j,k)状态下要得到最优解，i+1列的状态
bool room[3][101];
void paint(int i, int j, int k);//在room中标出状态(i,j,k)后的灭火器使用情况

/*最优解的输出部分*/
int counter;//记录发射次数
void output(int i);	//输出矩形

int main()
{
	/*输入部分*/
	fin >> room_n >> shoot_k;
	for(int i=2;i>=1;i--)
		for(int j=1;j<=room_n;j++)
			fin >> v[i][j];
	for(int i=2;i>=1;i--)
		for(int j=1;j<=room_n;j++)
			fin >> f[i][j];
	/*计算部分*/
	unsigned min_loss=memo(0,0,0);
	paint(0,0,0);

	/*输出部分*/
	for(int i=1;i<=room_n;i++)	output(i);
	for(int j=shoot_k-counter;j>=1;j--)
		fout << "0 0 0 0\n";
	return 0;
}

//
int memo(int i,int j, int k)
{
	if(checked[i][j][k])	return dp[i][j][k];
	if(i==room_n)	return 0;
	dp[i][j][k]=INT_MAX;
	for(int jj=0,kk,ans;jj<=3;jj++)	//枚举第i+1行状态
	{
		if(jj==3&&(j==4||j==1||j==2))	jj++;	//上下都用时的状态修正
		kk=k+!(jj==0||jj==j||j==4);
		if(kk<=shoot_k)
			ans=memo(i+1,jj,kk)+loss(i+1,jj);
		else ans=INT_MAX;
		if(dp[i][j][k]>ans)
		{
			dp[i][j][k]=ans;
			build[i][j][k]=jj;
		}
	}
	assert(dp[i][j][k]<INT_MAX);
	checked[i][j][k]=true;
	return dp[i][j][k];
}
int loss(int i, int j)
{
/*状态j的定义:
	0：上层下层都不使用灭火器；
	1：上使用；2：下使用；3，4：上下都用
	其中3表示与此列相连的使用灭火器的房间最少组成1个完整矩形
	4表示与此列相连的使用灭火器的房间已经最少组成2个完整矩形*/
	switch(j)
	{
		case 0:
			return (f[1][i]+f[2][i]);	//上下都不用
		case 1:
			return(v[2][i]+f[1][i]);	//上用
		case 2:
			return(v[1][i]+f[2][i]);	//下用
		case 3:	//上下都用
		case 4:
			return(v[1][i]+v[2][i]);
	}
	assert(0);
}
//
void paint(int i, int j, int k)
{
	if(i==room_n)	return;
	assert(checked[i][j][k]);
	int jj=build[i][j][k];
	int kk=k+!(jj==0||jj==j||j==4);
	switch(jj)
	{
		case 0:
			break;	//上下都不用
		case 1:
			room[2][i+1]=1; break;	//上用
		case 2:
			room[1][i+1]=1; break;	//下用
		case 3:
		case 4:
			room[1][i+1]=room[2][i+1]=true; break;	//上下都用
		default:
			assert(0);
	}
	paint(i+1,jj,kk);
}
//
void output(int i)
{
	counter++;
	int ii;
	if(room[2][i]&&!room[1][i])	//上用
	{
		fout << 2 << ' ' << i << ' ';
		for(ii=i;ii<=room_n&&room[2][ii];ii++)	room[2][ii]=0;
		fout << 2 << ' ' << ii-1 << endl;
	}
	else if(room[1][i]&&!room[2][i])	//下用
	{
		fout << 1 << ' ' << i << ' ';
		for(ii=i;ii<=room_n&&room[1][ii];ii++)	room[1][ii]=0;
		fout << 1 << ' ' << ii-1 << endl;
	}
	else if(room[1][i]&&room[2][i])	//上下都用
	{
		fout << 1 << ' ' << i << ' ';
		for(ii=i;ii<=room_n&&room[1][ii]&&room[2][ii];ii++)	room[1][ii]=room[2][ii]=0;
		fout << 2 << ' ' << ii-1 << endl;
	}
	else counter--;	//上下都不用
}
//

可能你对下面的文章也感兴趣：

1. [NOI97]积木游戏(Game)
2. [USACO]Ordered Fractions
3. [NOI99]棋盘分割(Chessboard Division)

积木游戏(NOI’97)

SERCOI 最近设计了一种积木游戏。每个游戏者有N块编号依次为1 ，2，…，N的长方体积木。对于每块积木,它的三条不同的边分别称为”a边”、“b边”和”c边”，如下图所示：

游戏规则如下：

1. 从N块积木中选出若干块，并将它们分成M（l<=M<=N）堆，称为第1堆，第2 堆…，第M堆。每堆至少有1块积木，并且第K堆中任意一块积木的编号要大于第K+1堆中任意一块积木的编号(2<=K<=M)。
2. 对于每一堆积木,游戏者要将它们垂直摞成一根柱子,并要求满足下面两个条件：
3. • 除最顶上的一块积木外，任意一块积木的上表面同且仅同另一块积木的下表面接触，并且要求下面的积木的上表面能包含上面的积木的下表面，也就是说，要求下面的积木的上表面的两对边的长度分别大于等于上面的积木的两对边的长度。
   • 对于任意两块上下表面相接触的积木，下面的积木的编号要小于上面的积木的编号。

最后，根据每人所摞成的M根柱子的高度之和来决出胜负。

请你编一程序，寻找一种摞积木的方案，使得你所摞成的M根柱子的高度之和最大。

输入输出

输入文件是INPUT.TXT。文件的第一行有两个正整数N和M（1<=M<=N<=100），分别表示积木总数和要求摞成的柱子数。这两个数之间用一个空格符隔开。接下来N行依次是编号从1到N的N个积木的尺寸，每行有三个1至1000之间的整数，分别表示该积木a边,b边和c边的长度。同一行相邻两个数之间用一个空格符隔开。

输出文件是OUTPUT.TXT。文件只有一行，为一个整数，表示M根柱子的高度之和。

样例

INPUT.TXT

4 2

10 5 5

8 7 7

2 2 2

6 6 6

OUTPUT.TXT

24

题解

好郁闷，这题我竟然连写带调花了将近一天。。。看来我的基本功的确非常不够。

这题对我的启发还是非常大的。lrj书中讨论了递推方向的选择问题，这是我不曾考虑过的。我以前所有的dp题目都是逆推的，状态表示都是“到此情况下为止能获得的最大/最小值”，我觉得这样表示非常自然。但这题行不通。每一个状态都有很多前趋状态，转移方程写起来非常困难。若顺推则容易得多，因为顺推的情况下每一个状态只对应一个后继。但是顺推的思想让我非常不适应（可见我非常菜）。“此情况以后能获得的最值”，这种表示我仔细体会了很长时间才理解并适应，感觉受益匪浅。

当一个问题满足dp所需的一切但是方程写起来非常麻烦，不妨换个递推方向试试吧。

代码（若看不到请设法绕过gfw……orz）：

#include <fstream>
using namespace std;
ifstream fin("Input.txt");
ofstream fout("Output.txt");
int N,M;
struct demension{
	unsigned a,b,c;
}demen[101];

int dp[101][101][101][3];
inline int h(int a, int k)
{
	//memo调用的子过程，返回积木a第k面朝上时的高度
	assert(a>0&&a<=N);
	switch(k)
	{
		case 0:	return demen[a].c;
		case 1:	return demen[a].b;
		case 2:	return demen[a].a;
	}
	assert(0);
}
inline bool canput(int a, int k, int aa, int kk)
{
	//memo调用的子过程，返回a的k面能否容纳aa的kk面
	int i,j,ii,jj;
	switch(k)
	{
		case 0:
			i=demen[a].a;
			j=demen[a].b;
			break;
		case 1:
			i=demen[a].a;
			j=demen[a].c;
			break;
		case 2:
			i=demen[a].b;
			j=demen[a].c;
			break;
		default:
			assert(0);
	}
	if(i<j)	swap(i,j);
	switch(kk)
	{
		case 0:
			ii=demen[aa].a;
			jj=demen[aa].b;
			break;
		case 1:
			ii=demen[aa].a;
			jj=demen[aa].c;
			break;
		case 2:
			ii=demen[aa].b;
			jj=demen[aa].c;
			break;
		default:
			assert(0);
	}
	if(ii<jj)	swap(ii,jj);
	return (i>=ii&&j>=jj);
	//这里的题意我开始理解错了，不需要j>=ii。这个错误让我花了一下午调试
}
int memo(int i, int a, int b, int k)
{
	/*已经用前a块积木摆成了i根柱子，顶面积木b的的面k朝上
	之后还能获得的最大高度（决策是否使用a+1块积木、如何使用）*/
	if(dp[i][a][b][k]!=0)	return dp[i][a][b][k];
	if(a==N)	//边界条件
		if(i==M)	return 0;
		else	return INT_MIN;
	int ans=memo(i,a+1,b,k);	//不使用第a+1块积木
	if(i<M)
		for(int kk=0;kk<=2;kk++)
			if(ans<memo(i+1,a+1,a+1,kk)+h(a+1,kk))
				ans=memo(i+1,a+1,a+1,kk)+h(a+1,kk);	//新起一堆
	if(i>0)//这个条件的疏忽让我调试了一早上
		for(int kk=0;kk<=2;kk++)
			if(canput(b,k,a+1,kk)&&ans<memo(i,a+1,a+1,kk)+h(a+1,kk))
				ans=memo(i,a+1,a+1,kk)+h(a+1,kk);	//放在前一堆上
	dp[i][a][b][k]=ans;
	return ans;
}

int main()
{
	fin >> N >> M;
	for(int i=1;i<=N;i++)
		fin >> demen[i].a >> demen[i].b >> demen[i].c;
	demen[0].a=demen[0].b=demen[0].c=1001;
	fout << memo(0,0,0,0) << endl;
	return 0;
}

可能你对下面的文章也感兴趣：

1. [NOI99]棋盘分割(Chessboard Division)
2. [POI VI Stage 1 Problem 1] Musketeers
3. [USACO]Mixing Milk

棋盘分割（NOI99）
Chessboard Division
Chess.{pas|bas|c}
Chess.exe

将一个８×８的棋盘进行如下分割：将原棋盘割下一块矩形棋盘并使剩下部分也是矩形，再将剩下的部分继续如此分割，这样割了(n-1)次后，连同最后剩下的矩形棋盘共有n块矩形棋盘。(每次切割都只能沿着棋盘格子的边进行)

原棋盘上每一格有一个分值，一块矩形棋盘的总分为其所含各格分值之和。现在需要把棋盘按上述规则分割成n块矩形棋盘，并使各矩形棋盘总分的均方差最小。

请编程对给出的棋盘及n，求出均方差σ的最小值。

输入
第1行为一个整数n(1
第2行至第9行每行为8个小于100的非负整数，表示棋盘上相应格子的分值。每行相邻两数之间用一个空格分隔。

输出
仅一个数，为σ（四舍五入精确到小数点后三位）。

样例输入
3
1 1 1 1 1 1 1 3
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 0
1 1 1 1 1 1 0 3

样例输出
1.633

题解

现在NOI的题做起来还是很费事……那个sigma的式子的化简则完全是参照lrj的牛书完成的，好失败……

中间调试了相当一段时间，都是由于些弱智错误……囧

#include <fstream>
#include <cassert>
#include <cmath>
#include <iomanip>
using namespace std;
ifstream fin("chess.in");
ofstream fout("chess.out");
int N;

unsigned score[8][8][8][8];
bool scored[8][8][8][8];
unsigned get_score(int x1, int y1, int x2, int y2)
{
   assert(x1<=x2&&y1<=y2);
   if(scored[x1][y1][x2][y2])   return score[x1][y1][x2][y2];
   scored[x1][y1][x2][y2]=true;
   unsigned sum=0;
   for(int x=x1;x<=x2;x++)
      for(int y=y1;y<=y2;y++)
         sum+=score[x][y][x][y];
   score[x1][y1][x2][y2]=sum;
   return sum;
}

unsigned dp[8][8][8][8][15];
bool checked[8][8][8][8][15];
unsigned memo(int x1, int y1, int x2, int y2, int n)
{
   assert(x1<=x2&&y1<=y2);
   if(checked[x1][y1][x2][y2][n])
      return dp[x1][y1][x2][y2][n];
   checked[x1][y1][x2][y2][n]=true;
   if(n==1)
   {
      dp[x1][y1][x2][y2][n]
                =get_score(x1,y1,x2,y2)*get_score(x1,y1,x2,y2);
      return dp[x1][y1][x2][y2][n];
   }

   unsigned ans=INT_MAX;
   for(int x=x1,m;x<x2;x++)
   {
      m=memo(x+1,y1,x2,y2,n-1);
      if(m<INT_MAX)
         ans=min(ans,get_score(x1,y1,x,y2)*get_score(x1,y1,x,y2)
            +memo(x+1,y1,x2,y2,n-1));
      m=memo(x1,y1,x,y2,n-1);
      if(m<INT_MAX)
         ans=min(ans,memo(x1,y1,x,y2,n-1)
            +get_score(x+1,y1,x2,y2)*get_score(x+1,y1,x2,y2));
   }
   for(int y=y1,m;y<y2;y++)
   {
      m=memo(x1,y+1,x2,y2,n-1);
      if(m<UINT_MAX)
         ans=min(ans,get_score(x1,y1,x2,y)*get_score(x1,y1,x2,y)
            +memo(x1,y+1,x2,y2,n-1));
      m=memo(x1,y1,x2,y,n-1);
      if(m<UINT_MAX)
         ans=min(ans,memo(x1,y1,x2,y,n-1)
            +get_score(x1,y+1,x2,y2)*get_score(x1,y+1,x2,y2));
   }
   dp[x1][y1][x2][y2][n]=ans;
   return ans;
}

int main()
{
   fin >> N;
   for(int y=0;y<=7;y++)
      for(int x=0;x<=7;x++)
      {
         fin >> score[x][y][x][y];
         scored[x][y][x][y]=true;
      }
   double x_=double(get_score(0,0,7,7))/N;
   fout << fixed << setprecision(3)
      << sqrt(double(memo(0,0,7,7,N))/N-x_*x_) << endl;
   return 0;
}

可能你对下面的文章也感兴趣：

1. [POI VI Stage 1 Problem 1] Musketeers
2. [USACO]Mixing Milk
3. [USACO]Arithmetic Progressions

POI VI Stage 1 Problem 1

Musketeers

In the time of Louis XIII and his powerful minister cardinal Richelieu in the Full Barrel Inn n musketeers had consumed their meal and were drinking wine. Wine had not run short and therefore the musketeers were eager to quarrel, a drunken brawl broke out, in which each musketeer insulted all the others.

A duel was inevitable. But who should fight who and in what order? They decided (for the first time since the brawl they had done something together) that they would stay in a circle and draw lots in order. A drawn musketeer fought against his neighbor to the right. A looser “quit the game” and to be more precise his corpse was taken away by servants. The next musketeer who stood beside the looser became the neighbor of a winner.

After years, when historians read memories of the winner they realized that a final result depended in a crucial extent on the order of duels. They noticed that a fence practice had indicated, who against who could win a duel. It appeared that (in mathematical language) the relation “A wins B” was not transitive! It could happen that the musketeer A fought better than B, B better than C and C better than A. Of course, among three of them the first duel influenced the final result. If A and B fight as the first, C wins eventually. But if B and C fight as the first, A wins finally. Historians fascinated by their discovery decided to verify which musketeers could survive. The fate of France and the whole civilized Europe indeed depended on that!

Task

N persons with consecutive numbers from 1 to n stay in a circle. They fight n-1 duels. In the first round one of these persons (e.g. with the number i) fights against its neighbor to the right, i.e. against the person numbered i+1 (or, if i=n, against the person numbered 1). A looser quits the game, and the circle is tighten so that the next person in order becomes a winner’s neighbor. We are given the table with possible duels results, in the form of a matrix. If Ai,j = 1 then the person with the number i always wins with the person j. If Ai,j = 0 the person i looses with j. We can say that the person k may win the game if there exists such a series of n-1 drawings, that k wins the final duel.

Write a program which:

l        reads matrix A from the text file MUS.IN,

l        computes numbers of persons, who may win the game,

l        writes them into the text file MUS.OUT.

Input

In the first line of the text file MUS.IN integer n which satisfies the inequality 3<=n<=100 is written. In each of the following n lines appears one word consisting of n digits 0 or 1. A digit on j-th position in i-th line denote Ai,j. Of course Ai,j = 1 – Aj,i, for i<>j. We assume that Ai,i = 1, for each i.

Output

In the first line of the output file MUS.OUT there should be written m – the number of persons, who may win the game. In the following m lines numbers of these persons should be written in ascending order, one number in each line.

Sample Input

7

1111101

0101100

0111111

0001101

0000101

1101111

0100001

Sample Output

3

1

3

6

Remark

The order of duels: 1-2, 1-3, 5-6, 7-1, 4-6, 6-1 gives a final victory to the per also check that only two persons more (1 and 3) may win the game.

Solution

调了好几遍，环有时总是处理不好，郁闷……

代码：

/*
ID: tom.tun1
PROG: mus
LANG: C++
*/
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("mus.in");
ofstream fout("mus.out");
bool checked[101][101],dp[101][101],win[101][101];
int N;
bool memo(int i, int j)
{
	if(checked[i][j])	return dp[i][j];
	int ii=i,jj=j;
	if(i==N)	ii=0;
	if(ii>=j)	jj+=N;
	if(jj-ii==1)	return(dp[i][j]=checked[i][j]=1);
	for(int kk=ii+1,k;kk<jj&&!dp[i][j];kk++)
	{
		if(kk>N)	k=kk-N;
		else k=kk;
		dp[i][j]=	memo(i,k)&&memo(k,j)
					&&(win[i][k]||win[j][k]);
	}
	checked[i][j]=true;
	return dp[i][j];
}
int main()
{
	fin >> N;
	for(int i=1;i<=N;i++)
	{
		char buf=fin.get();
		for(int j=1;j<=N;j++)
			win[i][j]=((buf=fin.get())=='1');
	}

	int ans[100],ans_num=0;
	for(int i=1;i<=N;i++)
		if(memo(i,i))	ans[ans_num++]=i;
	fout << ans_num << endl;
	for(int i=0;i<ans_num;i++)
		fout << ans[i] << endl;
	return 0;
}

可能你对下面的文章也感兴趣：

1. [USACO]Ordered Fractions
2. [USACO]Arithmetic Progressions
3. [USACO]The Clocks

Ordered Fractions

Consider the set of all reduced fractions between 0 and 1 inclusive with denominators less than or equal to N.
Here is the set when N = 5:

 0/1 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 1/1

Write a program that, given an integer N between 1 and 160 inclusive, prints the fractions in order of increasing magnitude.

PROGRAM NAME: frac1

INPUT FORMAT

One line with a single integer N.

SAMPLE INPUT (file frac1.in)

 5

OUTPUT FORMAT

One fraction per line, sorted in order of magnitude.

SAMPLE OUTPUT (file frac1.out)

 0/1 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 1/1

SOLUTION

这是一道很好过的题目。我的方法是穷举所有可能的分数，然后排序后输出。就这种最直观最笨的方法也不会超时。代码很好写，这里就略去了。

下面是我在usaco的官方Analysis上看到的解法，它利用递归直接生成分数并输出，没有互质数判断，没有排序。真是非常漂亮——虽然其中数学原理我还是有点搞不懂。比如：它怎么保证每次得到的分数分子分母都互质的？两个分数分子分母分别相加的到的分数，为什么它的值一定介于两者之间？希望能有达人仔细解释。

下面是我翻译自usaco的：

下面是来自Russ的超快解法：

我们发现可以把0/1和1/1分别作为起点和终点，然后通过增大分子和分母来递归地生成中间的点。

每个分数都是由它左边和右边的分数生成的。这种想法有助于在递归过深时跳出。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

int n;
FILE *fout;

/* 打印在n1/d1和n2/d2之间且分母小于等于n的分数*/
void
genfrac(int n1, int d1, int n2, int d2)
{
  if(d1+d2 > n)  /*跳出递归*/
  return;

  genfrac(n1,d1, n1+n2,d1+d2);
  fprintf(fout, "%d/%d\n", n1+n2, d1+d2);
  genfrac(n1+n2,d1+d2, n2,d2);
}

void
main(void)
{
  FILE *fin;

  fin = fopen("frac1.in", "r");
  fout = fopen("frac1.out", "w");
  assert(fin != NULL && fout != NULL);

  fscanf(fin, "%d", &n);

  fprintf(fout, "0/1\n");
  genfrac(0,1, 1,1);
  fprintf(fout, "1/1\n");
}

P.S.据查，这个解法利用了法里数列及其相关性质。详细信息参见我找到的资料：资料1 资料2

可能你对下面的文章也感兴趣：

1. [USACO]Mixing Milk
2. [USACO]Arithmetic Progressions
3. [USACO]Milking Cows / [Vijos1165]火烧赤壁

Arithmetic Progressions

An arithmetic progression is a sequence of the form a, a+b, a+2b, …, a+nb where n=0,1,2,3,… . For this problem, a is a non-negative integer and b is a positive integer.

Write a program that finds all arithmetic progressions of length n in the set S of bisquares. The set of bisquares is defined as the set of all integers of the form p² + q² (where p and q are non-negative integers).

TIME LIMIT: 5 secs

PROGRAM NAME: ariprog

INPUT FORMAT

SAMPLE INPUT (file ariprog.in)

 5 7

OUTPUT FORMAT

If no sequence is found, a singe line reading `NONE’. Otherwise, output one or more lines, each with two integers: the first element in a found sequence and the difference between consecutive elements in the same sequence. The lines should be ordered with smallest-difference sequences first and smallest starting number within those sequences first.

There will be no more than 10,000 sequences.

SAMPLE OUTPUT (file ariprog.out)

 1 4 37 4 2 8 29 8 1 12 5 12 13 12 17 12 5 20 2 24

SOLUTION

这道题就是简单的穷举，但是搞不好就超时。下面是星牛的解析：

这道题就是暴力搜索，时限是5s，方法是很简单的：枚举所有的可能解，没有剪枝的。

但是在编程细节上要注意，很多时候你的程序复杂度没有问题，但常数过大就决定了你的超时（比如说，你比别人多赋值一次，这在小数据时根本没有区别，但对于1个运行5s的大数据，你可能就要用10s甚至更多）。

具体来说，预处理把所有的bisquare算出来，用bene[i]记录i是否是bisquare，另外为了加速，用list记录所有的 bisquare（除去中间的空位置，这在对付大数据时很有用），list中的数据要有序。

然后枚举list中的数，把较小的作为起点，两数的差作为公差，接下来就是用bene判断是否存在n个等差数，存在的话就存入path中，最后排序输出。

运行时间：case 8 超时 （case 7 4.xs）

我一度曾抱怨Pascal的代码不够高效，想用c++编，但用不惯，于是又拐回Pascal来。

费时最多的地方是枚举list中的数，所以对这个地方的代码加一些小修改，情况就会不一样：

1.在判断是否存在n个等差数时，从末尾向前判断（这个不是主要的）。

2.在枚举list中的数时，假设为i,j，那么如果list[i]+(list[j]-list[i])×(n-1)>lim（lim是最大可能的bisquare），那么对于之后的j肯定也是大于lim的，所以直接break掉。（这个非常有效）

AC，最大数据1.4xs。

事实上我第一次写就和这个完全一样。但是就是AC不了：第八个点开始时间就超过5s了……狂ft了一阵，试着加了些优化，还是不行，晕啊~~明明和人家的做法一样怎么就是不过呢？莫非数据改了？还是rob这会子在测评机上玩魔兽，导致速度变慢？

百思不得其解后，我找了个牛的源码仔细看了看，恍然大悟。星牛所说的利用 list[i]+(list[j]-list[i])×(n-1)>lim 进行剪枝应该是放在每次check之前。如果已经大于最大值了，则直接跳出循环，对下一个首项进行穷举。而我则是放到check之内，仅仅避免了当前枚举的首项和第二项中的计算，没有想到再继续在首项不变的情况下枚举第二项已经没有意义了。

就是这样一个小小的差别，导致了高达4s的差距。真是细节决定成败！

源码：

/*
ID:tom.tun1
PROG:ariprog
LANG:C++
*/
#include <iostream>
#include <fstream>
#include <ctime>
using namespace std;
ifstream fin("ariprog.in");
ofstream fout("ariprog.out");
int prog_len, max_num;
bool set[125001] =
{
  0
};
int bsq[31375], bsq_num = 0, max_bsq;
int ans_num = 0;
struct Answer
{
  int a;
  int b;
}ans[40000];
int
cmp(const void* a, const void* b)
{
  return (*(int *) a - *(int *) b);
}
int
cmp2(const void* a, const void* b)
{
  struct Answer* aa = (Answer*) a;
  struct Answer* bb = (Answer*) b;
  if ((aa->b) != (bb->b))
      return((aa->b) - (bb->b));
  else
      return((aa->a) - (bb->a));
}
void
check(int a, int b)/*给出首项a和公差b，检查等差数列长度并处理*/
{
  for (int i = 0; i < prog_len / 2 + 1; i++)
      if (!set[a + b * i] || !set[a + b * (prog_len - 1 - i)])
          return;
  ans[ans_num].a = a;
  ans[ans_num].b = b;
  ans_num++;
}
int
main()
{
  fin >> prog_len >> max_num;
  max_bsq = max_num * max_num * 2;
  for (int p = 0; p <= max_num; p++)
      for (int q = p; q <= max_num; q++)
        {
          int n = p* p + q* q;
          if (!set[n])
            {
              set[n] = true;
              bsq[bsq_num++] = n;
            }
        }
  qsort(bsq, bsq_num, sizeof(bsq[0]), cmp);
  for (int i = 0; i < bsq_num - prog_len + 1; i++)
      for (int j = i + 1; j < bsq_num; j++)
        {
          int a = bsq[i], b = bsq[j] - bsq[i];
          if (a + b * (prog_len - 1) > max_bsq)
              break;
          check(a, b);
        }
  if (ans_num == 0)
      fout << "NONE" << endl;
  else
    {
      qsort(ans, ans_num, sizeof(ans[0]), cmp2);
      for (int i = 0; i < ans_num; i++)
          fout << ans[i].a << ' ' << ans[i].b << endl;
    }
  return 0;
}

可能你对下面的文章也感兴趣：

1. [USACO]Mixing Milk
2. [USACO]The Clocks
3. [USACO]Milking Cows / [Vijos1165]火烧赤壁

 |-------|    |-------|    |-------|
 |       |    |       |    |   |   |
 |---O   |    |---O   |    |   O   |
 |       |    |       |    |       |
 |-------|    |-------|    |-------|
     A            B            C

 |-------|    |-------|    |-------|
 |       |    |       |    |       |
 |   O   |    |   O   |    |   O   |
 |   |   |    |   |   |    |   |   |
 |-------|    |-------|    |-------|
     D            E            F

 |-------|    |-------|    |-------|
 |       |    |       |    |       |
 |   O   |    |   O---|    |   O   |
 |   |   |    |       |    |   |   |
 |-------|    |-------|    |-------|
     G            H            I

9 9 12          9 12 12       9 12 12        12 12 12         12 12 12
6 6 6   5 ->    9  9  9   8-> 9  9  9   4 -> 12  9  9   9 ->  12 12 12
6 3 6           6  6  6       9  9  9        12  9  9         12 12 12

SOLUTION

1.广度优先搜索

这道题叙述感觉很像最少步数问题，因此我第一个想到的就是BFS。开始的思路是这样的：搜索树为一个”九叉树”，从根节点到每一个节点的路径代表一个操作序列。每一个节点扩展出9个节点。当在某一深度找到可行解时，则完成该深度所有节点的检查，取其中操作序列连接的数字最小的为答案。

但是很明显，这个算法在时间复杂度和空间复杂度上都不可接受。

我们又发现：1.任何一个操作执行4次就等于没有执行；2.同一个操作序列，各个操作的顺序改变不影响整个序列的操作效果。

根据以上两点，我们可以进行如下改进：1.任何操作不超过3次；2.为了避免同一操作序列由于顺序不同造成的节点重复，我们每次扩展节点时，都只对操作号大于当前操作号的操作进行尝试。

这样，我们就得到了一棵小得多的搜索树。这棵树的最大深度为3*9=27，节点数为4的9次方即262144，根节点到任意节点路径所代表的操作序列都是不重复的。（要知道原来的搜索树有无限的深度和节点数，且充满了重复）。而且我们发现，由于节点的生成方式，我们通过bfs找到的第一个可行解必然就是最优解。

/*
ID:tom.tun1
PROG:clocks
LANG:C++
*/
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
ifstream fin("clocks.in");
ofstream fout("clocks.out");
struct
{
  char Time[9];//九个钟表的状态：0,3,6,9
  char depth;//当前节点的深度
  char num[28];//记录到达该节点的各个操作编号
  char operate_times[9 + 1];//operate_times[i]的值为已经进行i操作的次数
  char operation;//记录直接得到本节点的操作
}Clocks[270000];
const char operate[9 + 1][6] =
{
  /*每个操作影响的钟表号，每个操作的序列以-1结尾*/
  0, 0, 0, 0, 0, 0, 0, 1, 3, 4, -1, 0, 0, 1, 2, -1, 0, 0, 1, 2, 4, 5, -1, 0,
  0, 3, 6, -1, 0, 0, 1, 3, 4, 5, 7, -1, 2, 5, 8, -1, 0, 0, 3, 4, 6, 7, -1, 0,
  6, 7, 8, -1, 0, 0, 4, 5, 7, 8, -1, 0
};

int
main()
{
  /*输入及初始化*/
  for (int i = 0,c; i < 9; i++)
    {
      fin >> c;
      if (c == 12)
          c = 0;
      Clocks[0].Time[i] = c + '0';
    }
  Clocks[0].depth = 0;
  Clocks[0].operation = 1;
  memset(Clocks[0].operate_times, 0, sizeof(Clocks[0].operate_times));

  /*BFS*/
  int head = 0, tail = 1;/*首尾指针*/
  bool flag = true;
  while (flag && head < tail)
    {
      for (int i = Clocks[head].operation;
           i <= 9;
           i++)/*生成的i对应操作的编号*/
        {
          /*如果某操作执行超过3次则取消本次循环*/
          if (Clocks[head].operate_times[i] + 1 > 3)
              continue;

          /*产生节点*/
          strcpy(Clocks[tail].Time, Clocks[head].Time);/*Time[9]部份*/
          for (int j = 0; operate[i][j] != -1; j++)
            {
              int n = operate[i][j];
              if (Clocks[head].Time[n] == '9')
                  Clocks[tail].Time[n] = '0';
              else
                  Clocks[tail].Time[n] = Clocks[head].Time[n] + 3;
            }
          Clocks[tail].depth = Clocks[head].depth + 1;/*depth部份*/
          strcpy(Clocks[tail].num, Clocks[head].num);/*num[]部份*/
          Clocks[tail].num[Clocks[head].depth] = i + '0';
          /*operate_times[]部份*/
          memcpy(Clocks[tail].operate_times, Clocks[head].operate_times,
                 sizeof(Clocks[0].operate_times));
          Clocks[tail].operate_times[i]++;
          Clocks[tail].operation = i;/*operation部份*/
          /*节点产生完毕*/

          /*判断是否达到目标节点*/
          flag = false;
          for (int j = 0; j < 9; j++)
              if (Clocks[tail].Time[j] != '0')
                {
                  flag = true;
                  break;
                }
          if (!flag)
              break;
          tail++;
        }
      head++;
    }

  /*输出答案*/
  for (int i = 0; i < strlen(Clocks[tail].num); i++)
    {
      if (i == strlen(Clocks[tail].num) - 1)
          fout << Clocks[tail].num[i] << endl;
      else
          fout << Clocks[tail].num[i] << ' ';
    }
  //system("pause");
  return 0;
}

2.深度优先搜索

当我们得到了上面那棵搜索树后，我们发现由于深度和节点数都不大，DFS是完全可行的，而且更易于编写，省去了节省内存空间的麻烦。如同ghost所说，此题穷举才是正解。我们搜索过程中不断更新得到的最优解，当整棵树都遍历后就输出答案。可见此算法耗时相当稳定。我这里根据深度进行了小小的剪枝，完美AC。有牛说其实完全可以不要任何剪枝的，时间就可以稳定在0.3s。

源码如下：

/*
ID:tom.tun1
PROG:clocks
LANG:C++
*/
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("clocks.in");
ofstream fout("clocks.out");
struct Clocks
{
  char Time[9];//九个钟表的状态：0,3,6,9
  int depth;//当前节点的深度
  char num[28];//记录到达该节点的各个操作编号
  int operate_times[9 + 1];//operate_times[i]的值为已经进行i操作的次数
}FirstClock;
const char operate[9 + 1][6] =
{
  /*每个操作影响的钟表号，每个操作的序列以-1结尾*/
  0, 0, 0, 0, 0, 0, 0, 1, 3, 4, -1, 0, 0, 1, 2, -1, 0, 0, 1, 2, 4, 5, -1, 0,
  0, 3, 6, -1, 0, 0, 1, 3, 4, 5, 7, -1, 2, 5, 8, -1, 0, 0, 3, 4, 6, 7, -1, 0,
  6, 7, 8, -1, 0, 0, 4, 5, 7, 8, -1, 0
};
char min_num[28], min_depth = 30;
void
search(struct Clocks Clock, int i)//DFS递归函数，Clock为当前节点，i操作编?
{
  /*节点产生*/
  struct Clocks NextClock;
  /*depth部分*/
  NextClock.depth = Clock.depth + 1;
  if (NextClock.depth > min_depth)
      return;
  /*num部分*/
  strcpy(NextClock.num, Clock.num);
  NextClock.num[NextClock.depth - 1] = i + '0';
  /*Time[9]部分*/
  strcpy(NextClock.Time, Clock.Time);
  for (int j = 0; operate[i][j] != -1; j++)
    {
      int n = operate[i][j];
      if (Clock.Time[n] == '9')
          NextClock.Time[n] = '0';
      else
          NextClock.Time[n] = Clock.Time[n] + 3;
    }
  /*operate_times部分*/
  memcpy(NextClock.operate_times, Clock.operate_times,
         sizeof(Clock.operate_times));
  if (++NextClock.operate_times[i] > 3)
      return;

  /*检查是否为目标节点*/
  if (strcmp(NextClock.Time, "000000000") == 0)
    {
      /*更新min_depth和min_num的值*/
      if (NextClock.depth < min_depth)
        {
          strcpy(min_num, NextClock.num);
          min_depth = NextClock.depth;
          return;
        }
    }

  /*递归*/
  for (int j = i; j <= 9; j++)
      search(NextClock, j);
}
int
main()
{
  /*输入及初始化*/
  for (int i = 0,c; i < 9; i++)
    {
      fin >> c;
      if (c == 12)
          c = 0;
      FirstClock.Time[i] = c + '0';
    }
  FirstClock.depth = 0;
  memset(FirstClock.operate_times, 0, sizeof(FirstClock.operate_times));

  /*DFS*/
  for (int i = 1; i <= 9; i++)
      search(FirstClock, i);

  /*输出答案*/
  for (int i = 0; i < min_depth; i++)
    {
      if (i == min_depth - 1)
          fout << min_num[i] << endl;
      else
          fout << min_num[i] << ' ';
    }
  return 0;
}

3.特殊方法

上面两种方法只是常规的，不足为奇。下面贴出我翻译自USACO官方Analysis的两种方法。非常精彩。

Lucian Boca提交了一种常数时间的解法

你可以预先计算一个如下的矩阵：

a[i][0],a[i][1],….,a[i][8]是“仅仅”将第i个钟表（0<=i<=8，共有9个钟表：0=A, 1=B, … 8=I）顺时针转动90度所必须的操作1、2、3…9的执行次数。这样你就得到了一个矩阵：

int a[9][9]= { {3,3,3,3,3,2,3,2,0},
{2,3,2,3,2,3,1,0,1},
{3,3,3,2,3,3,0,2,3},
{2,3,1,3,2,0,2,3,1},
{2,3,2,3,1,3,2,3,2},
{1,3,2,0,2,3,1,3,2},
{3,2,0,3,3,2,3,3,3},
{1,0,1,3,2,3,2,3,2},
{0,2,3,2,3,3,3,3,3} };

这意味着仅仅将钟表0（钟表A）顺时针转动90度，你必须执行{3,3,3,3,3,2,3,2,0}，即操作1执行3次，操作2执行3次，…，操作8执行2次，操作9执行0次，等等。

仅仅将钟表8（钟表I）顺时针转动90度，你必须执行{0,2,3,2,3,3,3,3,3}：操作1执行0次，操作2执行2次…操作9执行3次…

没错！你可以在一个数组v[9]里记录每一种必须执行操作的次数，答案就是它取4的模（任何一种操作执行5次与执行1次效果一样）。源码：

#include <stdio.h>

int a[9][9]= { {3,3,3,3,3,2,3,2,0},
               {2,3,2,3,2,3,1,0,1},
               {3,3,3,2,3,3,0,2,3},
               {2,3,1,3,2,0,2,3,1},
               {2,3,2,3,1,3,2,3,2},
               {1,3,2,0,2,3,1,3,2},
               {3,2,0,3,3,2,3,3,3},
               {1,0,1,3,2,3,2,3,2},
               {0,2,3,2,3,3,3,3,3} };
int v[9];

int main() {
    int i,j,k;
    freopen("clocks.in","r",stdin);
    for (i=0; i<9; i++) {
        scanf("%d",&k);
        for(j=0; j<9; j++)
             v[j]=(v[j]+(4-k/3)*a[i][j])%4;
    }
    fclose(stdin);

    k=0;
    freopen("clocks.out","w",stdout);
    for (i=0; i<9; i++)
        for (j=0; j<v[i]; j++)
            if (!k) { printf("%d",i+1); k=1; }
            else    printf(" %d",i+1);
    printf("\n");
    fclose(stdout);
    return 0;
}

这是来自Sopot Cela的另一种解法——没有循环，常数时间。但这个实在是极端的复杂：在比赛的环境下想要写对这样一个程序将是一种极限挑战。

program clocks;
const
  INV : array[3..12] of byte =(1, 0, 0, 2, 0, 0, 3, 0, 0, 0);

var inp, out: text;
    a, b, c, d, e, f, g, h, i: integer;
    ax, bx, cx, dx, ex, fx, gx, hx, ix,l: integer;
    t,an: array[1..9] of integer;
begin
    assign (inp, 'clocks.in'); reset (inp);
    readln(inp, ax, bx, cx);
    readln(inp, dx, ex, fx);
    readln(inp, gx, hx, ix);
    a:=inv[ax]; b:=inv[bx]; c:=inv[cx]; d:=inv[dx];
    e:=inv[ex]; f:=inv[fx]; g:=inv[gx]; h:=inv[hx];
    i:=inv[ix];
    t[1] := (8+a+2*b+c+2*d+2*e-f+g-h) mod 4;
    t[2] := (a+b+c+d+e+f+2*g+    2*i) mod 4;
    t[3] := (8+  a+2*b+  c  -d+2*e+2*f      -h+  i) mod 4;
    t[4] := (    a+  b+2*c+  d+  e+      g+  h+2*i) mod 4;
    t[5] := (4+  a+2*b+  c+2*d  -e+2*f+  g+2*h+  i) mod 4;
    t[6] := (  2*a+  b+  c+      e+  f+2*g+  h+  i) mod 4;
    t[7] := (8+  a  -b+    2*d+2*e  -f+  g+2*h+  i) mod 4;
    t[8] := (  2*a+    2*c+  d+  e+  f+  g+  h+  i) mod 4;
    t[9] := (8      -b+  c  -d+2*e+2*f+  g+2*h+  i) mod 4;
    assign(out, 'clocks.out'); rewrite(out);
    for a := 1 to 9 do
        for b := 1 to t[a] do Begin
            inc(l);
            an[l]:=a;
        end;
    for a:=1 to l-1 do
        write(out,an[a],' ');
    write(out,an[l]);
    writeln(out); close(out)
end.

可能你对下面的文章也感兴趣：

1. [USACO]Mixing Milk
2. [USACO]Milking Cows / [Vijos1165]火烧赤壁
3. [USACO]Friday the Thirteenth

Mixing Milk

Since milk packaging is such a low margin business, it is important to keep the price of the raw product (milk) as low as possible. Help Merry Milk Makers get the milk they need in the cheapest possible manner.

The Merry Milk Makers company has several farmers from which they may buy milk, and each one has a (potentially) different price at which they sell to the milk packing plant. Moreover, as a cow can only produce so much milk a day, the farmers only have so much milk to sell per day. Each day, Merry Milk Makers can purchase an integral amount of milk from each farmer, less than or equal to the farmer’s limit.

Given the Merry Milk Makers’ daily requirement of milk, along with the cost per gallon and amount of available milk for each farmer, calculate the minimum amount of money that it takes to fulfill the Merry Milk Makers’ requirements.

Note: The total milk produced per day by the farmers will be sufficient to meet the demands of the Merry Milk Makers.

PROGRAM NAME: milk

INPUT FORMAT

OUTPUT FORMAT

A single line with a single integer that is the minimum price that Merry Milk Makers can get their milk at for one day.

SOLUTION

这个题当然是巨弱的题，基本上即使不知道有贪心这回事的人也能凭感觉做出来。但是我看到官方的Analysis，觉得很不错，就发上来了。它用一个最简单的例子向我们展示了最优美的代码是怎样炼成的。

下面是代码我翻译的说明、注释。

因为我们获得的东西都是同样大小的（在这里是单位量的牛奶），贪心算法可以满足要求：我们按照出价对农夫们进行排序，然后向出价最低的农夫买牛奶，买光他的牛奶后在向下一个出价次低的农夫买。

实现方法：我们把数据读入Farmer结构体中，按照出价对数组进行排序，扫描数组，依次买牛奶直到牛奶量达到所需。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define MAXFARMER 5000

typedef struct Farmer Farmer;
struct Farmer {
 int p; /* 每加仑的价格*/
 int a; /* 要卖的总量*/
};

int
farmcmp(const void *va, const void *vb)
{
 return ((Farmer*)va)->p - ((Farmer*)vb)->p;
}

int nfarmer;
Farmer farmer[MAXFARMER];

void
main(void)
{
 FILE *fin, *fout;
 int i, n, a, p;

 fin = fopen("milk.in", "r");
 fout = fopen("milk.out", "w");

 assert(fin != NULL && fout != NULL);

 fscanf(fin, "%d %d", &n, &nfarmer);
 for(i=0; i<nfarmer; i++)
  fscanf(fin, "%d %d", &farmer[i].p, &farmer[i].a);

 qsort(farmer, nfarmer, sizeof(farmer[0]), farmcmp);

 p = 0;
 for(i=0; i<nfarmer && n > 0; i++) {
/* 向farmer[i]买尽可能多的牛奶，最大为amount n */
  a = farmer[i].a;
  if(a > n)
   a = n;
  p += a*farmer[i].p;
  n -= a;
 }

 fprintf(fout, "%d\n", p);
 exit(0);
}

加拿大的Ran Pang写道：

这里有个程序能在线性时间内解决问题的程序，而我觉得官方给出的算法是O(n log n)的。

#include<stdio.h>

#define MAXPRICE 1001

int amount_for_price[MAXPRICE]={0};
int N, M;

int Cal(void);
int Read(void);

int main(void) {
    Read();
    Cal();
    return 0;
}

int Cal(void) {
    int i;
    int price_total=0;
    int milk_total=0;
    for(i=0;i<MAXPRICE;i++) {
        if(amount_for_price[i]) {
            if(milk_total+amount_for_price[i]<N) {
                price_total+=(i*amount_for_price[i]);
                milk_total+=amount_for_price[i];
            }
            else {
                int amount_needed = N-milk_total;
                price_total+=(i*amount_needed);
                break;
            }
        }
    }
    {
        FILE* out=fopen("milk.out","w");
        fprintf(out,"%d\n",price_total);
        fclose(out);
    }
    return 0;
}

int Read(void) {
    FILE* in = fopen("milk.in","r");
    int i, price, amount;
    fscanf(in,"%d %d",&N,&M);
    for(i=0;i<M;i++) {
        fscanf(in, "%d %d", &(price), &(amount));
        amount_for_price[price]+=amount;
    }
    fclose(in);
    return 0;
}

另一个解法，来自SVK（这是哪啊？）的Adam Okruhlica

完全没有必要用O(nlgn)的时间对价格进行快排，因为价格有一个$1000的上界，而且我们知道所有价格都是整数。我们可以用count sort对数组进行排序。我们可以给每一个可用的价格（0..1000）建立一个“盒子”。我们把输入数据存入一个数组，然后扫描每一个农夫，记录他在（0..1000）数组中的下标，此下标就等于他的出价。因此我们可以把出价相同的农夫放入一个链表中。最后，我们从0到1000扫描整个数组，并从链表中取出农夫们的下标。这很容易实现，且时间复杂度为O(n)。

program milk;

type pList = ^List;
      List = record
                farmer:longint;
                next:pList;
              end;
      HeadList = record
                   head:pList;
                   tail:pList;
                  end;

var fIn,fOut:text;
    sofar,i,x,want,cnt,a,b:longint;
    sorted,cost,amount:array[1..5010] of longint;
    csort:array[0..1010] of HeadList;

    t:pList;

begin
    assign(fIn,'milk.in');reset(fIn);
    assign(fOut,'milk.out'); rewrite(fOut);

    readln(fIn,want,cnt);
    for i:=1 to cnt do readln(fIn,cost[i],amount[i]);

    for i:=0 to 1000 do begin
         new(csort[i].head);
         csort[i].tail:=csort[i].head;
         csort[i].head^.farmer:=-1;
    end;

    {向数组中存入下标}
    for i:=1 to cnt do begin

       t:=csort[cost[i]].tail;
       if t^.farmer = -1 then t^.farmer:=i;
       new(t^.next);
       t^.next^.farmer:=-1;
       csort[cost[i]].tail:=t^.next;
    end;

    {取出下标}
    x:=1;
    for i:=0 to 1000 do begin
        t:=csort[i].head;
        while t^.farmer > 0 do begin
          sorted[x]:=t^.farmer;
          inc(x);
          t:=t^.next;
        end;
    end;

    sofar:=0;
    for i:=1 to cnt do begin
      if want < amount[sorted[i]] then begin
        inc(sofar,want*cost[sorted[i]]);
        want:=0; break;
      end

      else inc(sofar,amount[sorted[i]]*cost[sorted[i]]);
      dec(want,amount[sorted[i]]);
    end;

    writeln(fOut,sofar);
    close(fOut);
end.

Dwayne Crooks写道：

我们真的需要一个SVK的Adam Okruhlica在解答中使用的链表吗？我不这么想。这里有一个解法，本质上和Adam的一样，却没有使用链表。此解法是O(max(MAXP,M)) 的（MAXP=1000，M<=5000）。编辑注：为了避免溢出，Dwayne应该使用 long long integers (64 bit)而非int。

#include <iostream>
#include <fstream>

#define MAXP 1000

using namespace std;

int main() {
    ifstream in("milk.in");
    ofstream out("milk.out");

    int N, M;
    int P[MAXP+1];

    in >> N >> M;
    for (int i = 0; i <= MAXP; i++) P[i]=0;
    for (int i = 0; i < M; i++) {
        int price, amt;
        in >> price >> amt;

         // 我们可以将价格相同的各个农民手中牛奶的总量相加
        // 因为x加仑售价c美分、
        //          y加仑售价c美分
        // 和x+y加仑售价c美分
        //      是一回事
        P[price] += amt;
    }

    // 贪心策略：尽可能多的买售价最低的
    int res = 0;
    for (int p = 0; p<=MAXP && N>0; p++) {
        if (P[p]>0) {
            res+=p*(N<P[p]?N:P[p]);
            N-=P[p];
        }
    }
    out << res << endl;

    in.close();
    out.close();

    return 0;
}

做为结语，保加利亚的Miroslav Paskov从以上所有精彩的想法中提炼出了这个简单的解法：

#include <fstream>
#define MAXPRICE 1001
using namespace std;

int main() {
    ifstream fin ("milk.in");
    ofstream fout ("milk.out");
    unsigned int i, needed, price, paid, farmers, amount, milk[MAXPRICE][2];
    paid = 0;
    fin>>needed>>farmers;
    for(i = 0;i<farmers;i++){
        fin>>price>>amount;
        milk[price][0] += amount;
    }
    for(i = 0; i<MAXPRICE && needed;i++){
        if(needed> = milk[i][0]) {
            needed -= milk[i][0];
            paid += milk[i][0] * i;
        } else if(milk[i][0]>0) {
            paid += i*needed;
            needed = 0;
        }
    }
    fout << paid << endl;
    return 0;
}

可能你对下面的文章也感兴趣：

1. [USACO]Milking Cows / [Vijos1165]火烧赤壁
2. [USACO]Friday the Thirteenth

 20

 36 33 34 33 35 35 34

SOLUTION

这个题没什么可说的。只是我是按照常规方法做的，但刚发现了更简单的方法，即利用蔡勒公式来解。这里把公式和用此公式解题的源码贴上来。

蔡勒（Zeller）公式：是一个计算星期的公式。

随便给一个日期，就能用这个公式推算出是星期几。

蔡勒（Zeller）公式如下：

w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1
公式中的符号含义如下，
w：星期；
c：世纪；
y：年（两位数）；
m：月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算，比如2003年1月1日要看作2002年的13 月1日来计算）；
d：日；[ ]代表取整，即只要整数部分。

下面以中华人民共和国成立100周年纪念日那天（2049年10月1日）来计算是星期几。过程如下：
w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1
=49+[49/4]+[20/4]-2×20+[26× (10+1)/10]+1-1
=49+[12.25]+5-40+[28.6]
=49+12+5-40+28
=54 (除以7余5)
即2049年10月1日（100周年国庆）是星期五。

不过，以上的公式都只适合于1582年10月15日之后的情形（当时的罗马教皇将恺撒大帝制订的儒略历修改成格里历，即今天使用的公历）。

import java.io.*;
import java.util.*;

class friday
{
 public static void main(String args[])
 {
  int n, c, y, m, w, yearAdjusted;
  final int d = 13;
  int[] weekday13thCount = new int[7];

  for (int i = 0; i < 7; i++)
   weekday13thCount[i] = 0;

  Scanner in = new Scanner(System.in);
  Formatter out = new Formatter(System.out);
  try
  {
   in = new Scanner(new FileInputStream("friday.in"));
   out = new Formatter(new FileOutputStream("friday.out"));
  }
  catch (IOException e)
  {
   System.exit(1);
  }

  n = in.nextInt();
  if (n != 0)
   for (int year = 1900; year <= 1900 + n - 1; year++)
    for (int month = 1; month <= 12; month++)
    {
     if (month <= 2)
     {
      m = month + 12;
      yearAdjusted = year - 1;
     }
     else
     {
      m = month;
      yearAdjusted = year;
     }
     c = yearAdjusted / 100;
     y = yearAdjusted % 100;
     w = ((c / 4) - (2 * c) + y + (y / 4) + (26 * (m + 1) / 10) + d - 1) % 7;
     if (w < 0)
      w += 7;
     weekday13thCount[w]++;
    }

  out.format("%d %d %d %d %d %d %d\n",
   weekday13thCount[6],
   weekday13thCount[0],
   weekday13thCount[1],
   weekday13thCount[2],
   weekday13thCount[3],
   weekday13thCount[4],
   weekday13thCount[5]
  );

  in.close();
  out.close();
  System.exit(0);
 }
}

可能你对下面的文章也感兴趣：

1. [USACO]Milking Cows / [Vijos1165]火烧赤壁

Milking Cows

Three farmers rise at 5 am each morning and head for the barn to milk three cows. The first farmer begins milking his cow at time 300 (measured in seconds after 5 am) and ends at time 1000. The second farmer begins at time 700 and ends at time 1200. The third farmer begins at time 1500 and ends at time 2100. The longest continuous time during which at least one farmer was milking a cow was 900 seconds (from 300 to 1200). The longest time no milking was done, between the beginning and the ending of all milking, was 300 seconds (1500 minus 1200).
Your job is to write a program that will examine a list of beginning and ending times for N (1 <= N <= 5000) farmers milking N cows and compute (in seconds):

• The longest time interval at least one cow was milked.
• The longest time interval (after milking starts) during which no cows were being milked.

PROGRAM NAME: milk2

INPUT FORMAT

OUTPUT FORMAT

A single line with two integers that represent the longest continuous time of milking and the longest idle time.

SOLUTION

这道题是本巨菜第一次做出的涉及区间处理的题（虽然至今搞不清“离散化”是什么意思），具有重大的意义~~~~~我是参照这个说明做的：

按照开始时间将挤奶信息升序排序，然后按照如下方法从左到右扫描一遍，即可得到结果。
设r1为最长连续挤奶时间，r2为最长连续空闲时间，r1、r2初始时均为0。
每条挤奶信息都是一个区间，那么我们用变量c记录当前连续区间，初始时当前区间变量为排序后的第一个区间(c=milk[1])。

如果下一个区间i和当前区间相交或当前区间包含区间i(milk[i].start<=c.end)，就将两个区间的并集作为当前区间 (c.end=max(c.end,milk[i].end))； 如果下一个区间i和当前区间不相交(milk[i].start>c.end)，则更新r1、r2的值(r1=max(r1,c.end- c.start)，r2=max(r2,milk[i].start-c.end))，并将区间i作为当前区间(c=milk[i])。

因为我们只在下一个区间和当前区间不相交时才会去更新最优解，所以最后一个连续区间我们并没有更新，因此别忘了再更新一下 r1(r1=max(r1,c.end-c.start))。
r1，r2即为所求。

源码如下：

/*
ID: tom.tun1
PROG: milk2
LANG: C++
*/
#include <iostream>
#include <fstream>
using namespace std;
ifstream fin("milk2.in");
ofstream fout("milk2.out");
struct time
{
  int start;
  int end;
}milk[5000], present;
int N, MaxWork = 0, MaxBreak = 0;
int Partition(int first, int end);
void QuickSort(int first, int end);
void compute(int j);
bool intersection(struct time, struct time);//判断是否有交集
struct time unite(struct time, struct time);//求并集 

int
main()
{
  fin >> N;
  for (int j = 0; j < N; j++)
      fin >> milk[j].start >> milk[j].end;
  QuickSort(0, N - 1);
  present = milk[0];

  for (int j = 1; j < N; j++)
      compute(j);
  MaxWork = max(MaxWork, present.end - present.start);
  fout << MaxWork << ' ' << MaxBreak << endl;
  return 0;
}

void
compute(int j)
{
  if (intersection(milk[j], present))
      present = unite(milk[j], present);
  else
    {
      MaxWork = max(MaxWork, present.end - present.start);
      MaxBreak = max(MaxBreak, milk[j].start - present.end);
      present = milk[j];
    }
}

bool
intersection(struct time a, struct time b)
{
  if (a.end < b.start || b.end < a.start)
      return false;
  else
      return true;
}

struct time
unite(struct time a, struct time b)
{
  struct time x;
  x.start = min(a.start, b.start);
  x.end = max(a.end, b.end);
  return x;
}

void
QuickSort(int first, int end)
{
  if (first < end)
    {
      int pivot = Partition(first, end);
      QuickSort(first, pivot - 1);
      QuickSort(pivot + 1, end);
    }
}
int
Partition(int first, int end)
{
  int i = first, j = end;
  while (i < j)
    {
      while (i < j && milk[i].start <= milk[j].start)
          j--;
      if (i < j)
        {
          swap(milk[i], milk[j]);
          i++;
        }
      while (i < j && milk[i].start <= milk[j].start)
          i++;
      if (i < j)
        {
          swap(milk[i], milk[j]);
          j--;
        }
    }
  return i;
}

虽然不优美，但是AC了~~~~多谢那位写题解的牛！

USACO上的Analysis提到里提到的方法一即此方法，方法二是我原来一直用的。方法三至今看不懂，渴望有达人解释一下，多谢！
我听从了ghost牛的建议进行手工单步，终于搞懂了官方给出的第三种解法，hoho~~~~兴奋中~~~~~这里特别感谢ghost给我讲qsort()是怎么用的……

该算法将每次有farmer开始或结束挤奶做为一个单独“事件”看待。每一个事件包括两个信息：事件的开始时间、该事件记录的是开始挤奶还是结束挤奶。其中后者可以用1和-1表示。先把所有事件按照时间先后排序。每次处理事件的第二个信息时直接加和即可。有人开始挤奶，人数就+1；有人结束挤奶，人数就-1.这样，我们只需要看此加和的值即能知道当前事件发生后有几个人在挤奶。

这样我们就能很容易地找到一个有人挤奶或无人挤奶的完整时间段的起始点和终点（也就是另一个完整时间段的起点）。得到长度后再与当前最大值比较……剩下就很容易了。

下面附上官方的此算法源码以及我加的详细注释（注释均针对前一语句）：

#include <fstream.h>
#include <stdlib.h>

struct event
{
 long seconds;   /*记录该事件发生时离早上5点有多少秒*/
 signed char ss; /*若该事件是某人开始挤奶，则为1；若是某人结束挤奶，则为-1*/
};

int eventcmp (const event *a, const event *b)
{
 if (a->seconds != b->seconds)
  return (a->seconds - b->seconds); /*早发生的事件排在前面*/

 return (b->ss - a->ss);
 /* 若两个事件同时发生，
     则记录某人开始挤奶的事件排在前面*/
}

int main ()
{
 ifstream in;
 ofstream out;

 in.open("milk2.in");
 out.open("milk2.out");

 int num_intervals, num_events, i;
 /*num_intervals即输入的农夫数N，
    num_events即相应的事件数*/
 event events[5000 * 2];/*记录所有事件的数组*/

 in >> num_intervals;
 num_events = num_intervals * 2;/*很明显，事件数为农夫数的二倍*/
 for (i = 0; i < num_intervals; ++i)
 {
  in >> events[2*i].seconds; events[2*i].ss = 1;
  in >> events[2*i+1].seconds; events[2*i+1].ss = -1;
 }

 qsort(events, num_events, sizeof(event),
  (int(*)(const void*, const void*)) eventcmp);
  /*对所有事件进行排序，详见eventcmp处的注释*/

/* for (i = 0; i < num_events; ++i)
  out << events[i].seconds
    << (events[i].ss == 1 ? " start" : " stop") << endl; */
   /*测试一下排序结果如何*/

 int num_milkers = 0, was_none = 1;
 /*num_milkers为当前事件发生时挤奶者的数目
   （包括当前事件本身对其的影响），
    was_none为上一个事件发生时挤奶者的数目
   （包括上一事件本身对其的影响）*/
 int longest_nomilk = 0, longest_milk = 0;/*记录最大值的变量*/
 int istart, ilength;
 /*istart记录当前正在处理的完整时间段的起始位置，
    ilength是在比较当前完整时间段与最大完整时间段大小时的中间变量*/

 for (i = 0; i < num_events; ++i)
 {
  num_milkers += events[i].ss;

  if (!num_milkers && !was_none)
  /*当num_milkers==was_none==0时。
     num_milkers==0表示此时无挤奶者，
     was_none==0表示上一个“事件”时有挤奶者。
     这样后一个事件就成了上一挤奶完整时间段的终点
     和下一完整无人挤奶时间段的起点，
     应该计算结束的时间段长度并与longest_milk比较*/
 {
   ilength = (events[i].seconds - istart);
   if (ilength > longest_milk)
    longest_milk = ilength;
   istart = events[i].seconds;
  }
  else if (num_milkers && was_none)
  /*当num_milkers!=0&&was_none!=0时。
     num_milkers!=0表示此时有挤奶者，
     was_none!=0表示上一个“事件”时无挤奶者。
     这样后一个事件就成了上一无人挤奶完整时间段的终点
     和下一完整挤奶时间段的起点，
     应该计算计算结束的时间段长度并与longest_nomilk比较*/
  {
   if (i != 0)
   {
    ilength = (events[i].seconds - istart);
    if (ilength > longest_nomilk)
     longest_nomilk = ilength;
   }
   istart = events[i].seconds;
  }

  was_none = (num_milkers == 0);
 }

 out << longest_milk << " " << longest_nomilk << endl;

 return 0;
}

——————————————————————————–

解决了上面那道题，我就做了原来不会做的Vijos上的那个火烧赤壁，巩固一下方法。

描述 Description
曹操平定北方以后，公元208年，率领大军南下，进攻刘表。他的人马还没有到荆州，刘表已经病死。他的儿子刘琮听军声势浩大，吓破了胆，先派人求降了。

孙权任命周瑜为都督，拨给他三万水军，叫他同刘备协力抵抗曹操。

隆冬的十一月，天气突然回暖，刮起了东南风。

没想到东吴船队离开北岸大约二里距离，前面十条大船突然同时起火。火借风势，风助火威。十条火船，好比十条火龙一样，闯进曹军水寨。那里的船舰，都挤在一起，又躲不开，很快地都烧起来。一眨眼工夫，已经烧成一片火海。

曹操气急败坏的把你找来，要你钻入火海把连环线上着火的船只的长度统计出来！

输入格式 Input Format
第一行：N
以后N行，每行两个数：Ai  Bi(表示连环线上着火船只的起始位置和终点,-10^9<=Ai,Bi<=10^9)

输出格式 Output Format
输出着火船只的总长度

样例输入 Sample Input
3
-1 1
5 11
2 9

样例输出 Sample Output
11

注释 Hint
n<=20000
如果Ai=Bi是一个点则看作没有长度

题解 Solution

看看原来大牛们的题解吧：
线段树或者平面扫除法的一维情形
离散化+快排+二分查找，一定不会超时的^^

这种题解对我这样的巨菜来说和没有一样……现在终于通过Milking Cows搞定了这道问题。此题应该说比Milking Cows简单，只是要注意Ai=Bi的情况。

源码如下：

#include <iostream>
using namespace std;
int num=0;
struct ship{
 __int64 start;
 __int64 end;
}ships[20000],current;

struct ship Unite(struct ship,struct ship);
void QuickSort(int first,int end);
int Partition(int first,int end);
int main()
{
 int N;
 cin >> N;
 __int64 a,b;
 for(int i=0;i<N;i++)
 {
  cin >> a >> b;
  if(a!=b)
  {
   ships[num].start=a;
   ships[num].end=b;
   num++;
  }
 }
 QuickSort(0,num-1);
 /*for(int i=0;i<num;i++)
  cout << ships[i].start << '~' << ships[i].end << endl;*/

 __int64 length=0;
 current=ships[0];
 for(int i=1;i<num;i++)
 {
  if(ships[i].start>current.end)
  {
   length+=(current.end-current.start);
   current=ships[i];
  }
  else current=Unite(current,ships[i]);
 }
 length+=(current.end-current.start);
 cout << length << endl;
 return 0;
}

struct ship Unite(struct ship a,struct ship b)
{
 struct ship c;
 c.start=min(a.start,b.start);
 c.end=max(a.end,b.end);
 return c;
}

void QuickSort(int first,int end)
{
 if(first<end)
 {
  int pivot=Partition(first,end);
  QuickSort(first,pivot-1);
  QuickSort(pivot+1,end);
 }
}
int Partition(int first,int end)
{
 int i=first,j=end;
 while(i<j)
 {
  while(i<j&&ships[i].start<=ships[j].start) j--;
  if(i<j)
  {
   swap(ships[i],ships[j]);
   i++;
  }
  while(i<j&&ships[i].start<=ships[j].start) i++;
  if(i<j)
  {
   swap(ships[j],ships[i]);
   j--;
  }
 }
 return i;
}