NOIP2013提高組Day1 解題報告
阿新 • • 發佈：2019-02-11
總的來說
NOIP2013Day1的這三道題，感覺總的來說還是並不難，並且也比較符合套路。T1是良心的一眼送分題，T2是比較需要思考，程式碼寫起來比較簡單的但建立模型需要好好思考的偏重演算法思維的題目，T3是比較注重程式碼能力，程式碼量稍大(還是隻是因為我人傻寫得多?)的題目。
T1轉圈遊戲
在演草紙上模擬模擬，稍有常識的人就能看出這個求一下10^k後瞎搞搞就出來了。關鍵也就只是求下10^k，快速冪即可。 注意使用long long。
程式碼
#include <cstdio>
#include <cstdlib>
#include <iostream> T2火柴排隊
這個題就比較妙了，在cogs上難度係數甚至比當天的t3還高(當然cogs是標的難度係數我早已經不太相信了= =)。
這個題目要求最小化 ∑ (ai-bi)^2 (下標i=1,2..n)。展開這個式子得sum = ∑ ai^2 + bi^2 - 2ai×bi。其中∑ ai^2 + bi^2對於一組資料來說是一個定值，可看做常數，那麼現在要使得sum最小，就應使得 ∑ ai×bi 最大。這裡有個結論便是當a1<=a2…<=an且b1<=b2…<=bn時，∑ ai×bi值最大。我們可以這樣證明:對於任意的 a1 < a2∈序列a, b1 < b2∈序列b，若a1×b2+a2×b1 > a1×b1+a2×b2 則移項提公因式得a1(b2-b1) > a2(b2-b1)，消去得a1 > a2與條件a1 < a2相悖。 因此在滿足a1<=a2…<=an且b1<=b2…<=bn時，對於任意的 a1 < a2∈序列a, b1 < b2∈序列b有a1×b1+a2×b2 >= a1×b2+a2×b1。這就是告訴我們，每每兩個序列裡面名次相同的數配在一起，得到的∑ ai×bi值是最大的，這樣正是我們需要做的。
題目允許在兩列火柴上進行交換，但是顯然移動兩列火柴與只移動其中一列火柴是等價的(對兩個名次相同的數移動到同一位置的影響是等價的)。因此這裡可以固定序列A，只移動序列B。將B中元素在A中的位置找到構成一個序列C，對於這個序列C發現顯然有 對於任意的相鄰的i < j=i+1 ∈ [1,n]，若Ci>Cj那麼Ci與Cj需要發生一次交換。題目的答案即是交換的次數。交換的次數顯然就是序列C中逆序對(i
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdarg>
#include <list>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
#define MAXN 100003
#define MOD 99999997
int A[MAXN], B[MAXN];
int rkB[MAXN];
int ord[MAXN];
inline bool rankb(int a, int b)
{
return B[a] < B[b];
}
int ans = 0;
int tmp[MAXN];
void msort(int l, int m, int r)
{
int i = l;
int j = m+1;
int k = l;
while(i <= m && j <= r)
{
if(ord[i] > ord[j])
{
tmp[k++] = ord[j++];
ans = (ans+m-i+1)%MOD;
}else
{
tmp[k++] = ord[i++];
}
}
while(i <= m)tmp[k++] = ord[i++];
while(j <= r)tmp[k++] = ord[j++];
for(int p = l; p <= r; p++)
ord[p] = tmp[p];
}
void gg(int l, int r)
{
if(l < r)
{
int m = (l+r)>>1;
gg(l, m);
gg(m+1, r);
msort(l, m, r);
}
}
int main()
{
//freopen("MatchNOIP2013.in", "r", stdin);
//freopen("MatchNOIP2013.out", "w", stdout);
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i++)
scanf("%d", A+i);
for(int i = 1; i <= n; i++)
{
scanf("%d", B+i);
rkB[i] = i; //初始化B的名次
}
sort(rkB+1, rkB+1+n, rankb); //排序後滿足 B[rkB[i]] = B中第i小的數
//rkB[i] 即為B中第i小的數在B中的位置
for(int i = 1; i <= n; i++)
ord[i] = rkB[A[i]]; //rkB[A[i]]就是第A[i]小的數的位置
//這樣我們線上性的時間內快速找到了B中元素在A中對應的位置，儲存在ord陣列中
gg(1, n); //求個逆序對
printf("%d\n", ans);
return 0;
}
T3貨車運輸
也就是是每個司機都希望自己的路徑上的限重儘可能大，在這種情況下詢問自己路徑上限重的最小值。這個題目就比t2容易想多了，就連我這樣的蒟蒻也一眼(好吧其實還是我太蒟蒻了，第一樣看覺得像是網路流= =)看出來這，對於司機們這樣的要求可以構造最大生成樹，然後求最大生成樹上兩點之間限重最小值解決。
於是用kruskal演算法構造最大生成樹，樹鏈剖分+線段樹維護樹鏈上的最小值。程式碼洋洋灑灑寫了200+行還1A了。注意這個原圖上所有點不一定都在同一個聯通塊上，不過前面用kruskal的時候就已經順便並查集維護了一下聯通性，這多妙啊! 程式碼如下:
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <cctype>
using namespace std;
#define MAXN 10003
#define MAXM 50003
inline int fast_read()
{
int r;
char c;
while(c = getchar())
{
if(c >= '0' && c <= '9')
{
r = c^0x30;
break;
}
}
while(isdigit(c = getchar()))
r = (r<<3)+(r<<1)+(c^0x30);
return r;
}
struct edge
{
int from, to;
int value;
void scan()
{
from = fast_read();
to = fast_read();
value = fast_read();
}
bool operator<(const edge &o) const
{
return value > o.value;
}
}edges[MAXM];
vector<int> G[MAXN];
int n, m;
int uset[MAXN];
bool intree[MAXM];
int finds(int x)
{
return x == uset[x]? x:uset[x] = finds(uset[x]);
}
void make_maxtree()
{
sort(edges+1, edges+1+m);
for(int i = 1; i <= n; i++)uset[i] = i;
for(int i = 1; i <= m; i++)
{
edge &e = edges[i];
int x = finds(e.from);
int y = finds(e.to);
if(x != y)
{
intree[i] = true;
uset[x] = y;
}
}
}
int size[MAXN], top[MAXN], parent[MAXN], deep[MAXN], son[MAXN];
void dfs(int u, int f, int d)
{
parent[u] = f;
deep[u] = d;
size[u] = 1;
for(int i = 0; i < G[u].size(); i++)
{
int to = G[u][i];
if(to != f)
{
dfs(to, u, d+1);
size[u] += size[to];
if(size[to] > size[son[u]])
son[u] = to;
}
}
}
int has[MAXN];
int hasid = 0;
void dfs(int u, int tp)
{
has[u] = ++hasid;
top[u] = tp;
if(!son[u])return;
dfs(son[u], tp);
for(int i = 0; i < G[u].size(); i++)
{
int to = G[u][i];
if(to != parent[u] && to != son[u])
dfs(to, to);
}
}
int val[MAXN];
struct node
{
int l, r, ls, rs, minv;
}ns[MAXN<<1];
int root = 1;
int last = root;
void pushup(node &d)
{
d.minv = min(ns[d.ls].minv, ns[d.rs].minv);
}
int build(int l, int r)
{
if(l > r)return 0;
int cur = last++;
node &d = ns[cur];
d.l = l;
d.r = r;
if(l == r)
d.minv = val[l];
else
{
int m = (l+r)>>1;
if(l <= m)
{
d.ls = build(l, m);
d.rs = build(m+1, r);
pushup(d);
}
}
return cur;
}
int querytree(int c, int l, int r)
{
if(!c)return 0x7fffffff;
node &d = ns[c];
if(d.l == l && d.r == r)
return d.minv;
else if(l >= ns[d.rs].l)
return querytree(d.rs, l, r);
else if(r <= ns[d.ls].r)
return querytree(d.ls, l, r);
else
return min(querytree(d.ls, l, ns[d.ls].r), querytree(d.rs, ns[d.rs].l, r));
}
int query(int u, int v)
{
int ans = 0x7fffffff;
int t1 = top[u], t2 = top[v];
while(t1 != t2)
{
if(deep[t1] < deep[t2])
{
swap(t1, t2);
swap(u, v);
}
ans = min(ans, querytree(1, has[t1], has[u]));
u = parent[t1];
t1 = top[u];
}
if(u == v)return ans;
else
{
if(deep[u] > deep[v])
swap(u, v);
return min(ans, querytree(1, has[son[u]], has[v]));
}
}
int main()
{
// freopen("truck.in", "r", stdin);
// freopen("truck.out", "w", stdout);
n = fast_read();
m = fast_read();
for(int i = 1; i <= m; i++)
edges[i].scan();
make_maxtree();
for(int i = 1; i <= m; i++)
{
if(intree[i])
{
edge &e = edges[i];
G[e.from].push_back(e.to);
G[e.to].push_back(e.from);
}
}
for(int i = 1; i <= n; i++)
if(!size[i]) //沒有去過這個點
{
dfs(i, 0, 1);
dfs(i, i);
}
for(int i = 1; i <= m; i++)
{
if(intree[i])
{
edge &e = edges[i];
if(deep[e.to] < deep[e.from])
swap(e.from, e.to);
val[has[e.to]] = e.value;
}
}
build(1, hasid);
int q;
q = fast_read();
while(q--)
{
int x, y;
x = fast_read();
y = fast_read();
if(finds(x) != finds(y))
puts("-1");
else
printf("%d\n", query(x, y));
}
return 0;
}
/*
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3
*/