小测(noip2005的两道题) 2017.3.3

过河

题目描述 Description

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

输入描述 Input Description

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

输出描述 Output Description

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

样例输入 Sample Input

10
2 3 5
2 3 5 6 7

样例输出 Sample Output

2

数据范围及提示 Data Size & Hint

对于30%的数据，L<=10000；
对于全部的数据，L<=10⁹。

---

　　考虑优化一下暴力 dp 的部分。

定理 如果正整数 $a, b$ 满足 $a > 1$ 或者 $b > 1$，且 $(a, b) = 1$，那么 $ax + by (x \geqslant 0, y \geqslant 0)$ 不能表示出的最小自然数是 $ab - a - b$

　　证明 首先考虑证明不存在 $x, y$ 使得 $ax + by = ab - a - b$。假设存在整数 $x, y$。

　　那么有 $a(x + 1) + b(y + 1) = ab$。

　　所以 $a \mid b(a + y + 1)$，所以 $a \mid (y + 1)$。同理可得 $b | (x + 1)$。

　　因为 $x \geqslant 0, y \geqslant 0, ab > 0$，所以 $a(x + 1) + b(y + 1) \geqslant ab + ab = 2ab > ab$，矛盾。

　　然后证明对于任意自然数 $c > ab - a - b$ 都能表示出来。根据裴蜀定理有，存在整数$x_0, y_0$，使得 $a(x_0 + kb) + b(y_0 - ka) = d$，如果 $x_0 \geqslant 0, y_0 \geqslant 0$ 那么找到了一组合法的解，如果 $x_0 <0, y_0 < 0$ 显然不可能，否则 $x_0 < 0$ 或 $y_0 < 0$，不妨设 $x_0 \geqslant 0, y_0 < 0$，如果 $x_0 \geqslant b$，那么令 $x_0' = x_0 - b, y_0' = y_b + a$ ，所以只用考虑当 $0 \leqslant x_0 < b, y_0 < 0$ 的情况，此时有 $a \cdot x_0 + b\cdot y_0 \leqslant ab - a - b$，这和 $a \cdot x_0 + b\cdot y_0 = c > ab - a - b$ 矛盾。

　　如果 $T > S$，那么至少包含 $x$ 和 $x + 1$，因为 $(x, x + 1) = 1$，所以对于长度大于 $x(x + 1) - x - x - 1 < 100$ 的长度可以直接看成 100，因为它们总能走到。

　　如果 $T = S$，可以简单处理掉。

Code

 #include<iostream>
 #include<cstdio>
 #include<cctype>
 #include<cstring>
 #include<cstdlib>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<queue>
 #include<vector>
 #include<stack>
 using namespace std;
 typedef bool boolean;
 #define INF 0xfffffff
 #define smin(a, b) a = min(a, b)
 #define smax(a, b) a = max(a, b)

 ifstream fin("river.in");
 ofstream fout("river.out");

 int M, L;
 int l, r;
 int* d;
 int* s;
 int* f;

 inline void init() {
     fin >> L;
     fin >> l >> r >> M;
     d = new int[(const int)(M + )];
     for(int i = ; i <= M; i++)
         fin >> d[i];
     sort(d + , d + M + );
 }

 inline void solve() {
     if(l == r) {
         int res = ;
         for(int i = ; i <= M; i++) {
             if(d[i] % l == )
                 res++;
         }
         fout << res;
         return;
     }
     s = new int[(const int)(M *  + )];
     memset(s, , sizeof(int) * (M *  + ));
     d[] = ;
     int newd = ;
     for(int i = ; i <= M; i++) {
         if(d[i] - d[i - ] > )
             newd += ;
         else newd += d[i] - d[i - ];
         s[newd]++;
     }
     f = new int[(const int)(newd +  + r)];
     memset(f, 0x3f, sizeof(int) * (newd +  + r));
     f[] = ;
     for(int i = ; i <= newd; i++) {
         if(f[i] > M)    continue;
         for(int j = l; j <= r; j++)
             smin(f[i + j], f[i] + s[i + j]);
     }
     int res = M;
     for(int i = newd; i <= newd + r; i++)
         if(f[i] >= )
             smin(res, f[i]);
     fout << res;
 }

 int main() {
     init();
     solve();
     return ;
 }

---

题目描述 Description

　　佳佳刚进高中，在军训的时候，由于佳佳吃苦耐劳，很快得到了教官的赏识，成为了“小教官”。在军训结束的那天晚上，佳佳被命令组织同学们进行篝火晚会。一共有n个同学，编号从1到n。一开始，同学们按照1，2，……，n的顺序坐成一圈，而实际上每个人都有两个最希望相邻的同学。如何下命令调整同学的次序，形成新的一个圈，使之符合同学们的意愿，成为摆在佳佳面前的一大难题。
佳佳可向同学们下达命令，每一个命令的形式如下：
(b₁,b₂,...b_m-1,b_m)
　　这里m的值是由佳佳决定的，每次命令m的值都可以不同。这个命令的作用是移动编号是b1，b2，…… bm –1，bm的这m个同学的位置。要求b1换到b2的位置上，b2换到b3的位置上，……，要求bm换到b1的位置上。
　　执行每个命令都需要一些代价。我们假定如果一个命令要移动m个人的位置，那么这个命令的代价就是m。我们需要佳佳用最少的总代价实现同学们的意愿，你能帮助佳佳吗？

输入描述 Input Description

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

输出描述 Output Description

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

样例输入 Sample Input

4
3 4
4 3
1 2
1 2

样例输出 Sample Output

2

数据范围及提示 Data Size & Hint

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

---

　　因为这是一个环，所以可以剖环成链，因为剖开点不一样，就会导致结果不一样，所以正着反着每个地方都去剖一次。

　　接下来是考虑如何快速地求解需要付出的代价。这个代价等于所有在它不该在的位置的数量。

　　这个结论可以这么来说明，对于一个在它不该在的位置的i，那么必定存在它占掉另一个的位置且另一个占掉了它的位置，当按照这个关系连接起来就等于一个环，刚好可以按照题目中的变换方式(旋转这个环)，把环上的数变到它应该在的位置。

　　但是这么做仍然会超时，所以得继续考虑优化。对于改变剖开点的位置，我们规定每次改变把剖开点向前挪动一次，那么我们可以记录每个位置上的数，离它第一次回到自己正确位置上需要挪动剖开点多少次，然后就找个最大值，然后用n一减就可以出结果。

　　注意判断是否可以满足所有需求。主要的原因是:a希望坐在b，c旁边，但是b,c中有人不是最希望坐在a的旁边。

Code

 #include<iostream>
 #include<cstdio>
 #include<cctype>
 #include<cstring>
 #include<cstdlib>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<queue>
 #include<vector>
 #include<stack>
 using namespace std;
 typedef bool boolean;
 #define INF 0xfffffff
 #define smin(a, b) a = min(a, b)
 #define smax(a, b) a = max(a, b)

 template<typename T>class Matrix{
     public:
         T *p;
         int lines;
         int rows;
         Matrix():p(NULL){    }
         Matrix(int rows, int lines):lines(lines), rows(rows){
             p = new T[(lines * rows)];
         }
         T* operator [](int pos){
             return (p + pos * lines);
         }
 };
 #define matset(m, i, s) memset((m).p, (i), (s) * (m).lines * (m).rows)

 ifstream fin("fire.in");
 ofstream fout("fire.out");

 int n;
 Matrix<int> sit;
 int* exist;

 inline void init() {
     fin >> n;
     sit = Matrix<int>(n + , );
     exist = new int[(const int)(n + )];
     memset(exist, , sizeof(int) * (n + ));
     for(int i = ; i <= n; i++) {
         fin >> sit[i][] >> sit[i][];
         for(int j = ; j < ; j++) {
             exist[sit[i][j]]++;
             if(exist[sit[i][j]] >  || sit[i][j] == i) {
                 fout << "-1";
                 exit();
             }
         }
     }
     for(int i = , c; i <= n; i++) {
         for(int j = ; j < ; j++) {
             c = sit[i][j];
             if(sit[c][] != i && sit[c][] != i) {
                 fout << "-1";
                 exit();
             }
         }
     }
 }

 int myabs(int x) {    return (x < ) ? (x + n) : (x);    }

 int* list;
 int* round;

 int calc(int x) {
     list[] = ;
     list[] = sit[][x];
     int last = list[];
     memset(round, , sizeof(int) * (n + ));
     round[]++, round[myabs( - last)]++;
     int ret = max(round[], round[myabs( - last)]);
     for(int i = , j; i <= n; i++) {
         if(sit[last][] == list[i - ])
             list[i] = sit[last][];
         else list[i] = sit[last][];
         last = list[i];
         j = myabs(i - last);
         round[j]++;
         smax(ret, round[j]);
     }
     return ret;
 }

 int res = INF;
 inline void solve() {
     list = new int[(const int)(n + )];
     round = new int[(const int)(n + )];
     for(int i = , a; i < ; i++) {
         a = calc(i);
         smin(res, n - a);
     }
     fout << res;
 }

 int main() {
     init();
     solve();
     return ;
 }