NOIP2018（更新中）

\(Day_1T_1\) 铺设道路 （Link）

现在你有一个序列，每一个\(i\)有一个深度\(Deep[i]\)，现在你可以选择任意的区间，将整个区间的\(Deep\)都减少\(1\)。但前提是这个区间不能有任意一个点的\(Deep\)大于等于\(0\)。求进行多少次操作可以将整个序列的所有\(Deep\)置为\(0\)。

这个题的数据范围比较的大，\(1 ≤ n ≤ 100000,0 ≤ d_i ≤ 10000\)。观察发现时间复杂度应该限制在\(O(N)\)或者\(O(NlogN)\)以内，当然如果可以\(O(logN)\)更好，但这个好像是无法实现的。
\(O(NlogN)\)：这个是笔者在考场上想出来的，五分钟敲完发现秒了大样例就走了。用的方法是一个二分。我们发现你选择的这个区间的限制不在于\(Deep[i]_{Max}\)，而在于\(Deep[i]_{Min}\)。什么意思呢。比如这个区间\(\{4~ 3~ 2~ 5~ 3~ 5 \}\)。
我们肯定首先要整体切两次。因为整个区间内的最小值为\(2\)，然后区间变为\(\{2~ 1~ 0~ 3~ 1~ 3 \}\)出现了\(0\)，我们再考虑做其他的事情。
于是我们发现了算法流程：
\(1.\)对于区间\([L, R]\)，寻找到区间最小的点的位置\(Pos\)
\(2.\)\(Ans += Deep[Pos]\)
\(3.\)二分\([L, Pos - 1]\), \([Pos + 1, R]\)。
遍历\([L, R]\)总时间复杂度是\(O(N)\)，二分的时间复杂度是\(O(logN)\)，总时间复杂度\(O(NlogN)\)。也算是卡着过去了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std ;

typedef long long LL ;
const int MAXN = 100010 ;
const int Inf = 0x7fffffff ;
LL N, Data[MAXN], Tag[MAXN], Max[MAXN][23], Ans ;

inline LL Read() {
    LL X = 0, F = 1 ; char ch = getchar() ;
    while (ch > '9' || ch < '0') F = (ch == '-') ? - 1 : 1, ch = getchar() ;
    while (ch >= '0' && ch <= '9') X=(X<<1)+(X<<3)+(ch^48), ch = getchar() ;
    return X * F ;
}

inline void Erfen(int L, int R, int T) {
    if (L == R) {
        Ans += Data[L] - T ;
        return ;
    }   LL Min = Inf, Pos = 0 ;
    for (int i = L ; i <= R ; i ++)
        Pos = Min > Data[i] ? i : Pos, Min = Min > Data[i] ? Data[i] : Min ;
    Min -= T ; Ans += Min ;
    if(Pos > L) Erfen(L, Pos - 1, T + Min) ;
    if(Pos < R) Erfen(Pos + 1 , R, T + Min) ;
    return ;
}

int main() {
    N = Read() ;
    for (int i  = 1 ; i <= N ; i ++) Data[i] = Read() ;
    int L = 1, R = N ;  LL Min = Inf, Pos = 0 ;
    for (int i = 1 ; i <= N ; i ++)
        Pos = Min > Data[i] ? i : Pos, Min = Min > Data[i] ? Data[i] : Min ;
    Ans += Min ;
    if (Pos > 1) Erfen(1, Pos - 1, Min) ;
    if (Pos < N) Erfen(Pos + 1, N, Min) ;
    printf("%lld", Ans) ;
    fclose(stdin) ; fclose(stdout) ;
    return 0 ;
}

\(O(N)\)：如果你愿意在考场上多花一点时间思考一下以保证\(AC\)的话，你可以发现这其实就是一个贪心，你发现对于两个相邻的数\(Deep[i]\)和\(Deep[i + 1]\)，如果\(Deep[i] > Deep[i + 1]\)，那么我们肯定会要把两个坑都填上，这时如果我们选择了区间[i, i + 1]，你发现根本就不需要加上\(Deep[i + 1]\)所要耗费的次数，因为他一定会被\(i\)点顺带着填掉。那么我们发现贪心的规律：对于每一个\(i\), 如果\(Deep[i] > Deep[i + 1]\)（当然也可以是小于，没有分别），\(Ans += Deep[i] - Deep[i + 1]\)。
复杂度\(O(N)\)，没有什么问题；

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std ;

typedef long long LL ;
const int MAXN = 100010 ;
const int Inf = 0x7fffffff ;
LL N, Deep[MAXN], Ans ;

inline LL Read() {
    LL X = 0, F = 1 ; char ch = getchar() ;
    while (ch > '9' || ch < '0') F = (ch == '-') ? - 1 : 1, ch = getchar() ;
    while (ch >= '0' && ch <= '9') X=(X<<1)+(X<<3)+(ch^48), ch = getchar() ;
    return X * F ;
}

int main() {
    N = Read() ;
    for (int i = 1 ; i <= N ; i ++) {
        Deep[i] = Read() ;
        Ans += (Deep[i] > Deep[i - 1]) ? (Deep[i] - Deep[i - 1]) : 0 ;
    }   printf("%lld", Ans) ; return 0 ;
}

\(Day_1T_2\) 货币系统（Link）

现在你有一个叫做货币系统的东西，里面包括\(N\)种货币面值和面值的集合A。我们把这种货币集合叫做(N, A)。我们定义两个货币集合相等，当且仅当对于每一个数\(X\),它要么都能被两个系统表示，要么都不能。求与(N, A)相等的货币系统的最小的\(N\)。

实际上这到题考的就是一个完全背包。我们分析样例
\(4\)
\(3~ 19~ 10~ 6\)
可以发现，这里面的\(6\)可以被两个\(3\)表示，因此它无用，\(19\)可以被一个\(10\)和\(3\)个\(3\)表示，因此它也无用。所以得出答案就是2种。
于是我们发现，如果有一种面值是可以被其余的面值表示出来的，那么它就可以被筛掉。于是我们找到了算法流程：
\(1.\)从大到小排序。并且我们知道最小的面值一定要选。
\(2.\)对于每一个\(Data[i]\)，如果它已经被标记，那么\(continue\)。
\(3.\)计数器\(Ans++\)，标记\(F[Data[i]] = 1\)
\(4.\)从当前的\(Data[i]\)开始循环足够多的数，如果\(F[j - Data[i]] = 1\)，那么代表加上\(Data[i]\)之后还是可以被筛掉，那么\(F[j] = 1\)。
\(Over\)，时间复杂度为\(O(25000TN)\)算一算发现没有超时。完美。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;
typedef long long LL ;
const int MAXN = 10010 ;
const int MAXM = 25000 ;

int N, M, Data[MAXN], T, F[MAXM], Total ;

inline int Read() {
    int X = 0, F = 1 ; char ch = getchar() ;
    while (ch > '9' || ch < '0') F = (ch == '-' ? - 1 : 1), ch = getchar() ;
    while (ch >= '0' && ch <= '9') X=(X<<1)+(X<<3)+(ch^48), ch = getchar() ;
    return X * F ;
}

inline bool CMP(int X, int Y) { return X < Y ; }

int main() {
    T = Read() ; while (T --) {
        N = Read() ; Total = 0 ;
        memset(Data, 0, sizeof(Data)) ;
        memset(F, 0, sizeof(F)) ;
        for (int i = 1 ; i <= N ; i ++)
            Data[i] = Read(), M = max(M, Data[i]) ;
        sort(Data + 1 , Data + N + 1, CMP) ;
        for (int i = 1 ; i <= N ; i ++) {
            if (F[Data[i]]) continue ;
            Total ++ ; F[Data[i]] = 1 ;
            for (int j = Data[i] ; j <= M ; j ++)
                if (F[j - Data[i]]) F[j] = 1 ;
        }   printf("%d\n", Total) ;
    }   return 0 ;
}

\(Day_2T_1\) 旅行（Link）

你有一张\(N\)点\(M\)边的无向图，现在你可以从任意一个点出发，或者走向与它链接的没有走过的点，或者沿着d第一次访问该点的时候经过的城市退到上一个点。必须走完所有的点，要求输出字典序最小的方案。

\(Subtask_1 ~ M = N - 1\)

这显然是一个树，我们显然要从\(1\)号节点出发，然后每一次选择与他相连的子节点中最小的点，那么我们可以对每一个点连接的点进行一个从小到大的排序，然后进行一遍\(Dfs\)就可以了。思考难度接近\(0\)，但是占了\(60\)的高分，这大概也就是为什么它的难度排在了\(Day_2T_1\)。

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std ;
typedef long long LL ;
const int MAXN = 5050 ;
const int MAXM = 5050 ;

int N, M, Tot, H[MAXN], SF, ST, Ans[MAXN], Cnt ;
int E[MAXN][MAXN], Edge[MAXN][2], L[MAXN] ;
bool Vis[MAXN] ;

inline int Read() {
    int X = 0, F = 1 ; char ch = getchar() ;
    while (ch > '9' || ch < '0') F = (ch == '-' ? - 1 : 1), ch = getchar() ;
    while (ch >= '0' && ch <= '9') X=(X<<1)+(X<<3)+(ch^48), ch = getchar() ;
    if (ch == '-') return -X;
    return X;
}

inline void Doit(int Now, int Fa) {
    printf("%d ", Now) ;
    sort(E[Now] + 1, E[Now] + H[Now] + 1) ;
    for (int i = 1 ; i <= H[Now] ; i ++)
        if (E[Now][i] != Fa) Doit(E[Now][i], Now) ;
}

int main() {
    N = Read() ; M = Read() ;
    for (int i = 1 ; i <= M ; i ++) {
        int X = Read(),  Y = Read() ;
        E[X][++ H[X]] = Y ; E[Y][++ H[Y]] = X ;
        Edge[i][0] = X ; Edge[i][1] = Y ;
    }
    if (M == N - 1) Doit(1, 0) ;
    return 0 ;
}

\(Subtask_2 ~ M = N\)

这个就有一点难度了，起码不是那种让人一眼瞧出来的那种。我们发现这种图就是比一棵树多了一条边，那么我们知道它肯定会构成一个环并且仅会构成一个环，所以我们知道这是个基环树。

题目要求的是走完所有的点，则只可能走\(N - 1\)条边，也就是时候不论怎么走都会剩下一条边没走，那么我们就可以采取暴力手段，每次选取一条边把他删掉，确切的来说是记录下来，然后\(Dfs\)的时候如果碰到这条边就不走，然后对于每次的方案取最优即可。

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std ;
typedef long long LL ;
const int MAXN = 5050 ;
const int MAXM = 5050 ;

int N, M, Tot, H[MAXN], SF, ST, Ans[MAXN], Cnt ;
int E[MAXN][MAXN], Edge[MAXN][2], L[MAXN] ;
bool Vis[MAXN] ;

inline int Read() {
    int X = 0, F = 1 ; char ch = getchar() ;
    while (ch > '9' || ch < '0') F = (ch == '-' ? - 1 : 1), ch = getchar() ;
    while (ch >= '0' && ch <= '9') X=(X<<1)+(X<<3)+(ch^48), ch = getchar() ;
    if (ch == '-') return -X;
    return X;
}

inline void Doit(int Now, int Fa) {
    printf("%d ", Now) ;
    sort(E[Now] + 1, E[Now] + H[Now] + 1) ;
    for (int i = 1 ; i <= H[Now] ; i ++)
        if (E[Now][i] != Fa) Doit(E[Now][i], Now) ;
}

inline void Dfs(int Now, int Fa) {
    L[++ Cnt] = Now ; Vis[Now] = 1 ;
    for (int i = 1 ; i <= H[Now] ; i ++) {
        if(! Vis[E[Now][i]] && ! ((Now == SF && E[Now][i] == ST) ||(Now == ST && E[Now][i] == SF)))
            Dfs(E[Now][i], Now) ;
    }
}

inline bool Judge() {
    for (int i = 1 ; i <= N ; i ++)
        if (Ans[i] != L[i]) return Ans[i] > L[i] ;
    return false ;
}

inline void WORK() {
    memset(Ans, 127, sizeof(Ans)) ; memset(Vis, 0, sizeof(Vis)) ;
    for (int i = 1 ; i <= N ; i ++) sort(E[i] + 1, E[i] + H[i] +1) ;
    //把每一条边连接的点都排序 

    for (int i = 1 ; i <= M ; i ++) { Cnt = 0 ;
        memset(L, 0, sizeof(L)) ; memset(Vis, 0, sizeof(Vis)) ;
        SF = Edge[i][0], ST = Edge[i][1] ;
        Dfs(1, 0) ;
        if (Judge() && Cnt == N)
            for (int i = 1 ; i <= N ; i ++)
                Ans[i] = L[i] ;
    }
    for (int i = 1 ; i <= N ; i ++) printf("%d ", Ans[i]) ;
}

int main() {
    N = Read() ; M = Read() ;
    for (int i = 1 ; i <= M ; i ++) {
        int X = Read(),  Y = Read() ;
        E[X][++ H[X]] = Y ; E[Y][++ H[Y]] = X ;
        Edge[i][0] = X ; Edge[i][1] = Y ;
    }
    if (M == N - 1) Doit(1, 0) ;
    else WORK() ;     return 0 ;
}

其实仔细想一想这道题也并不是特别的难，如果只停留在暴力删边的方法上的话。这里直接爆删是没法通过所有的测试点的，但是\(88\)分的成绩也不错了，加上在\(Dfs\)的过程中的一些最优性剪枝和玄学优化的话是可以卡过去的。然而还有一种十分玄的做法是边删边维护以做到\(O(N)\)，就不再说了（懒

以及可以扩展到不限制\(M\)的情况下在仙人掌图上做，可是我不会~~~