XIN隊算法
騙分導論
已同步到 \(cnblog\) 中
\(newly\;upd:2021.10.18\)
\(newly\;upd:2021.8.4\)
\(newly\;upd:2021.8.1\)
\(newly\;upd:2021.7.8\)
\(newly\;upd:2021.6.6\)
OI至高算法，只要XIN隊算法打滿，保證所有比賽 \(rk1\)，碾爆標程，讓對手望塵莫及。
請慎用
注：名稱由莫隊算法改編而來
XIN隊算法：
1.遇到不會做的題目不用慌，你要想到你還有XIN隊算法，仔細讀題，理解題目意義，然后開始准備寫XIN隊算法。
2.這時候，你可以瀟灑地敲出：
void xin_team()
然后開始暴搜
XIN隊算法框架：
void xin_team(參數)
{
if(邊界) return;
for(register int i=1;i<=n;++i)
if(條件1)
{
狀態轉移
xin_team(參數);
狀態回溯
}
}
但是，對於不同的題目, void xin_team 並不能解決所有的題目，那該怎么辦呢？？？
對於很多不能用XIN隊\(1\)號算法的，大多數可以使用XIN隊\(2\)號算法：
next_permutation(a+1,a+n+1); 大法
框架：
void xin_team2
{
do
{
答案記錄
}while(next_permutation(a+1,a+n+1));
}
非常完美
但是，由於XIN隊算法時間復雜度 只有 \(\mathcal O(2^n)\)或者是\(\mathcal O(n!)\)，所以我們提出優化：
優化XIN隊算法：
非常不建議使用
框架：
srand((unsigned)time(0));
do
{
random_shuffle(a+1,a+n+1);
答案記錄
}while(next_permutation(a+1,a+n+1));
復雜度:
還附加超大常數
XIN隊算法升級：二維XIN隊
有很多很多的題目無法用普通的\(XIN\)隊算法解決，這時候我們就需要\(XIN\)隊算法升級版：\(\color{red}\huge_{\text{二維XIN隊}}\)
二維\(XIN\)隊對於代碼能力的提升是顯而易見的，然而對復雜度的提升更是顯而易見的，二維\(XIN\)隊算法框架：
比方說：
使用此算法，輕松 \(30pts\)
void xin_team2(int x,int now)
{
if(邊界)
{
xin_team2(x,now);
記錄
return ;
}
for(register int i=1;i<=n;++i)
{
記錄狀態
xin_team(x,now+1);
回溯狀態
}
}
void xin_team1(int x,int now)
{
if(邊界)
{
xin_team2(x,now);
記錄
return ;
}
for(register int i=1;i<=n;++i)
{
記錄狀態
xin_team(x,now+1);
回溯狀態
}
}
復雜度：
並且只能說是大概
我們發現，對於一般的題目，大多是 \(dp\) 解決，然而純粹運用上述方法只能拿到部分分數，甚至全部 \(TLE\) 所以，記憶化 \(XIN\) 隊算法應運而生。
對於優秀的記憶化 \(XIN\) 算法，想要什么狀態就去找什么狀態，然后就可以實現飛一般的提升。。。
包准快
使用記憶化 \(XIN\) 隊算法，\(NOI\)包准不打鐵！
比方說這個題： \(NOI2020\)美食家
使用 \(XIN\) 隊算法，輕輕松松 \(40pts\)
框架：
void xin_team(int i,int j)
{
if(f[i][j]) return f[i][j];
for(k ...)
xin_team(k,~);
return f[i][j];
}
算法的時間復雜度就是:
\(num\)為狀態，復雜度總體海星。。。
然而：
\(\color{red} \huge{\text{方程推不出}}\)
\(\color{green} \huge{\text{親人兩行淚}}\)
\(XIN\) 優化分塊預處理
一個月沒更了，這次在刷題的時候發現了最新的 \(XIN\) 隊算法應用
這是在寫蒲公英的時候發現的。
做了好長時間，中途還跑去做樹鏈去了。
時間相差的確實長了一些。。。
在用分塊解決這個問題的時候。
發現狂 \(T\) 不止。
但是。
不知道為什么在其他的 \(OJ\) 上都可以過掉
只不過就是很慢。
但是在學校的 \(OJ\) 上最多只有 \(70pts\)。
好評測機
然而並不敢找老師去開大時限
所以我只能優化暴力。。。
然后。
我發現在預處理 \(p_{i,j}\) 的時候，時間差的很多很多。
然而如果用 \(query\) 函數而不是暴力去搞就會錯。。。
因為有些需要的狀態還沒有附上值但是接下來處理需要用到。。。
所以我集中生智
發現了 \(XIN\) 隊優化分塊預處理法
我都沒想到 \(XIN\) 隊算法還有優化別的東西的一天
主要思想就是 缺啥找啥
然后狀態就有了。。。
雙指針突然不香了 \(\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\) --搖擺兵
然后飛快
void xin_team(int x,int y)
{
if(p[x][y]) return;
if(abs(y - x) <= 2) {p[y][x] = p[x][y] = query(l[x],r[y],0); return;}
xin_team(x+1,y-1);
p[x][y] = p[y][x] = query(l[x],r[y],0);
}
\(\color{red}{\huge{\uparrow \text{精華}}}\)
\(\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\huge{record}\)
鑒於有童鞋想要學習 clock() 騙分優化方法，那就更新一下下
對於 \(clock()\) 函數的使用，其實還是非常簡單的。
\(clock()\) 函數的返回值與 \(time(0)\) 有所不同，\(clock()\) 函數的返回值是從程序開始到你所調用 clock 函數的時間。 然而 \(time(0)\) 的返回值是 從歷史上的某一天開始的。所以這兩個函數的用法就有所不同。
-
clock() 直接使用就行
-
time(0)函數需要在程序開始的時候執行一次，之后在需要的時候再進行調用，之后作差就是程序運行時間。
但是， \(clock()\) 函數的返回值的單位並不是秒，所以我們需要將其進行處理。
CLOCKS_PER_SEC 是 \(C++\) 中的一個常數，在 \(Linux\) 系統下是 \(10^6\)，將 clock() / CLOCKS_PER_SEC 這樣處理就是以秒為單位了。
所以我們來一個判斷函數：
inline bool pan(){return ((double)clock() > 0.9 * CLOCKS_PER_SEC) ? false : true;}
然后就 \(okk\) 了。
打表騙分方法
關於打表的高級方法，一定要配合 \(XIN\) 隊算法使用。
但是如果機子不行。。。。。
就會。。。。
但是沒有什么關系，能騙到分就好。狗頭.jpg
舉個例子，一次模擬賽的時候，場均 \(T3\) 暴力 \(40pts\) ，而善於騙分的我搞到了 \(60pts\)，為什么呢？？？
看代碼吧。。。
騙分代碼
#include<bits/stdc++.h>
using std::cout; using std::endl;
#define try(i,a,b) for(register signed i=a;i<=b;++i)
#define throw(i,a,b) for(register signed i=a;i>=b;--i)
namespace xin_io
{
#define scanf nb = scanf
#define debug cout<<"debug"<<endl
#define gc() p1 == p2 and (p2 = (p1 = buf) + fread(buf,1,1<<2,stdin),p1 == p2) ? EOF : *p1++
char buf[1<<20],*p1 = buf,*p2 = buf,output[100]; FILE *xinnb;int nb;typedef long long ll; typedef unsigned long long ull;
void openfile() {xinnb = freopen("t.txt","r",stdin);} void outfile() {xinnb = freopen("o.txt","w",stdout);}
inline int get()
{
register int s = 0,f = 1; register char ch = gc(); while(!isdigit(ch)) {if(ch == '-') f = -1; ch = gc();}
while( isdigit(ch)) s = (s << 1) + (s << 3) + (ch xor 48),ch = gc();return s * f;
}
template<typename type>inline void write(type x)
{
if(!x) return putchar('0'),putchar('\n'),void(); if(x < 0) putchar('-'),x = -x;
register int cnt = 0;while(x) output[++cnt] = x % 10,x /= 10;
throw(i,cnt,1) putchar(output[i] xor 48);return putchar('\n'),void();
}
}
using namespace xin_io; static const int maxn = 1e7+10,inf = 1e9+7,mod = 123456789;
namespace xin
{
class xin_edge{public:int ver,next;}edge[maxn];
int head[maxn],zhi = 0;
inline void add(int x,int y) {edge[++zhi].ver = y; edge[zhi].next = head[x]; head[x] = zhi;}
int n,c[maxn],tot = 1;
std::vector<int>wit;
void dfs(int now,int col,int ms,int dep)
{
if(dep > ms) return ;
c[now] = col; if(col) wit.push_back(now);
if(col == 1) add(now,++tot),add(tot,now),dfs(tot,0,ms,dep+1);
else
{
add(now,++tot),add(tot,now); dfs(tot,0,ms,dep+1);
add(now,++tot),add(tot,now); dfs(tot,1,ms,dep+1);
}
}
int top[maxn],hson[maxn],siz[maxn],d[maxn],fa[maxn];
void dfs1(int x,int f)
{
d[x] = d[f] + 1; siz[x] = 1 ;fa[x] = f;
for(register int i=head[x];i;i=edge[i].next)
{
register int y = edge[i].ver;
if(y == f) continue;
dfs1(y,x);
siz[x] += siz[y];
if(siz[y] > siz[hson[x]]) hson[x] = y;
}
}
void dfs2(int x,int t)
{
top[x] = t;
if(hson[x]) dfs2(hson[x],t);
for(register int i=head[x];i;i=edge[i].next)
{
register int y = edge[i].ver;
if(y == hson[x] or y == fa[x]) continue;
dfs2(y,y);
}
}
inline int lca(int x,int y)
{
while(top[x] xor top[y])
{
if(d[top[x]] < d[top[y]]) std::swap(x,y);
x = fa[top[x]];
}
if(d[x] > d[y]) return y;return x;
}
ll ans[maxn];
inline void pianfen(int x)
{
if(x == 20) cout<<"0 2584 5777 4557 7605 9022 11669 14829 18539 24232 29932 39068 48230 63004 77615 101103 124353 161124 198103 252565 307548 396301 478075 611861 728718 922724 1078302 1342082 1520084 1844655 1989813 2299701 2232598 2408279 1948339 1576239 0 0 0 0"<<endl;
if(x == 21) cout<<"0 4181 9348 7374 12307 14601 18887 24005 30017 39245 48495 63330 78232 102307 126146 164738 202713 264511 323819 422659 510355 662171 804598 1037879 1251393 1602014 1907726 2415772 2822998 3513638 3979620 4829376 5209393 6020699 5845016 6304957 5100817 4126648 0 0 0 0"<<endl;
if(x == 22) cout<<"0 6765 15126 11932 19915 23628 30566 38852 48589 63536 78532 102583 126786 165875 204738 267526 329961 430592 530384 689630 849133 1093162 1337647 1732639 2107038 2716853 3276413 4193986 4994574 6324524 7390738 9198802 10418792 12643464 13638373 15762391 15302452 16506591 13354113 10803704 0 0 0 0 "<<endl;
if(x == 23) cout<<"0 10946 24475 19307 32225 38234 49463 62875 78639 102840 127132 166098 205342 268746 331861 433949 535569 700060 862665 1126695 1383953 1807734 2201400 2864363 3500485 4537055 5515724 7113163 8577537 10980139 13075882 16557868 19349170 24082798 27276740 33101025 35705719 41266479 40062338 43214817 34961521 28284465 0 0 0 0"<<endl;
if(x == 24) cout<<"0 17711 39602 31240 52143 61867 80039 101745 127261 166435 205769 268866 332452 435185 537576 703160 868425 1135609 1401511 1830731 2257551 2942351 3626859 4697612 5767288 7496572 9165909 11877217 14440926 18622153 22456507 28746236 34233186 43349012 50656818 63049562 71411444 86659602 93478791 108037041 104884564 113137859 91530451 74049690 0 0 0 0"<<endl;
if(x == 25) cout<<"0 28657 64078 50548 84371 100106 129512 164638 205933 269334 333006 435149 538118 704495 870414 1138794 1406889 1840626 2272638 2971832 3665969 4791540 5898360 7708953 9438484 12304948 15095008 19628708 23995141 31095905 37806262 48753779 58791675 75258764 89623562 113489236 9164449 41609129 63500787 103421001 121273858 35931071 27677774 49285183 116173042 70407817 0 0 0 0"<<endl;
if(x == 26) cout<<"0 46368 103681 81789 136517 161978 209561 266401 333227 435828 538880 704200 870894 1140244 1408967 1843639 2278209 2981192 3682611 4816969 5947985 7775346 9595320 12524886 15451508 20090552 24720660 32208332 39523192 51386197 62821615 81409189 98978652 4181912 30462038 73573072 111180825 50205050 100293364 61777795 119090933 100146603 23429212 123212956 101605549 34717689 10075098 13716971 0 0 0 0 "<<endl;
if(x == 27) cout<<"0 75025 167760 132338 220891 262089 339083 431057 539193 705221 871991 1139534 1409336 1845303 2280358 2984118 3687993 4826775 5963711 7803207 9638419 12608341 15563781 20352160 25089360 32805925 40304068 52614472 64709140 84328948 103469112 11076449 41010814 89676182 12215324 87249229 32594130 22003858 120462010 37125982 44802019 20267497 46858418 73562028 72470560 86794224 30225293 54867885 37509040 94199886 0 0 0 0"<<endl;
if(x == 28) cout<<"0 121393 271442 214128 357411 424072 548654 697476 872453 1141108 1410976 1843919 2280554 2986111 3690302 4829442 5969097 7812924 9654784 12634582 15610869 20425142 25229202 32995367 40740236 53231877 65709546 85646604 105544532 14272963 45964327 97312823 23976022 105296584 60212928 64161259 61124901 10651714 67320661 115895096 3291741 61172828 34112739 122481455 21484337 120539472 70525686 13712922 112527121 6429176 102452023 21969108 0 0 0 0"<<endl;
}
inline short main()
{
#ifndef ONLINE_JUDGE
openfile();
#endif
std::cin>>n;
if(n > 19)
{
pianfen(n);
return 0;
}
dfs(1,c[1]=1,n,1);
dfs1(1,0); dfs2(1,1);
try(i,0,wit.size()-1)
try(j,i+1,wit.size()-1)
{
register int x = wit[i],y = wit[j];
++ans[d[x] + d[y] - 2 * d[lca(x,y)]];
}
try(i,1,(n<<1))
printf("%lld ",ans[i] % mod);
return 0;
}
}
signed main() {return xin::main();}
現在知道為啥 
\(meet\;in\;middle\) 優化 XIN 算法
今天的一場考試讓我痛定思痛，明明有 \(35pts\) 的二維XIN隊板子卻沒有打對，掛成了可憐的 \(15pts\)，很是生氣。
查看題解，發現全新思路！！！！
\(meet\;in\;middle\) 優化 XIN 算法
很是開心，然后發現可以解決 \(n \leq 40\) 范圍的題目。
爆搜能力又增加了！！！
我們可以查看 P4799 [CEOI2015 Day2]世界冰球錦標賽 這個題目。
我們發現似乎 \(XIN\) 算法似乎有一萬分，然而。。。。
狂T不止
然而 \(meet\;in\;middle\) 之后：
\(meet\;in\;middle\) 的思想就好比這兩張圖片：
分開搜索，一定快，因為優化的是指數
復雜度：
好久好久沒有寫過這個玩意了。。。
然后昨天來了一個幾乎很多人都不會打爆搜的題目。
然后我打了一個迭代加深，似乎就比 puts("-1")高 5 分
所以就來說一說迭代加深。
實際上其實就是一個普通的dfsXIN隊。
根據昨天的題目:
我們要找到一個步數最小的方案。
但是我們的深度優先搜索會導致深度不斷增大，也就是深度優先
這樣如果我們剛開始就走錯了。。。那就。。。
所以..
那么我們就開始限制步數。
while(!dfs(++dep));
這樣就完了？？？
不，這是錯的！！
為啥？？
應該這樣
while(!xin_team(++dep));
\(\color{red}{perfect}\)
然后我們就限制了這個玩意的步數，只要 xin_team 的返回值為真，那么這個一定就是最優的答案。
所以，為啥不廣搜呢？？
我不會告訴你這個題目迭代加深有15分，然后廣搜有80的
完蛋的迭代加深
#include<bits/stdc++.h>
using std::cout; using std::endl;
#define try(i,a,b) for(register int i=a;i<=b;++i)
#define throw(i,a,b) for(register int i=a;i>=b;--i)
#define go(i,x) for(register signed i=head[x],y=edge[i].ver;i;i=edge[i].next,y = edge[i].ver)
namespace xin_io
{
#define file(x) freopen(#x".in","r",stdin); freopen(#x".out","w",stdout);
#define sb(x) std::cerr << #x" = "<<x<<' '
#define jb(x) std::cerr << #x" = "<<x<<endl
#define debug cout<<"debug"<<endl
#define gc() p1 == p2 and (p2 = (p1 = buf) + fread(buf,1,1<<20,stdin),p1 == p2) ? EOF : *p1 ++
#define scanf ak = scanf
char buf[1<<20],*p1 = buf,*p2 = buf; using ll = long long; using ull = unsigned long long; int ak;
class xin_stream{public:template<typename type>xin_stream operator >> (type &s)
{
s = 0; register bool f = 0; register char ch = gc();
while(!isdigit(ch)) f |= ch == '-',ch = gc();
while( isdigit(ch)) s = (s << 1) + (s << 3) + (ch xor 48),ch = gc(); return s = f ? -s : s,*this;
}}io;
}
using namespace xin_io; static const int maxn = 1e6+10,two = 1e2+10,inf = 1e9+10;
#define int long long
namespace xin
{
int n,m,qnum,cnt_w;
bool hard[two][two];
int goalx,goaly,nx,ny;
const int dx[] = {1,-1,0,0},dy[] = {0,0,1,-1};
bool dfs(int dep,int ex,int ey,int nowx,int nowy,int ms)
{
// sb(nowx); sb(nowy); sb(ex); sb(ey); jb(dep);
if(nowx == ex and nowy == ey) return false;
if(nowx == goalx and nowy == goaly) return true;
else if(dep == ms) return false;
if((nowx == ex and abs(nowy - ey) == 1) or (nowy == ey and abs(nowx - ex) == 1))
{
// sb(nowx); sb(nowy); sb(ex); jb(ey);
if(dfs(dep+1,nowx,nowy,ex,ey,ms)) return true;
}
try(i,0,3)
{
// sb(nowx); sb(nowy); sb(ex); jb(ey);
nx = ex + dx[i]; ny = ey + dy[i];
if(!hard[nx][ny] and nx <= n and nx >= 1 and ny <= m and ny >= 1)
if(dfs(dep+1,nx,ny,nowx,nowy,ms)) return true;
}
return false;
}
int ex,ey,nowx,nowy;
inline short main()
{
file(y);
io >> n >> m >> qnum;
try(i,1,n) try(j,1,m) io >> hard[i][j],hard[i][j] = !hard[i][j],cnt_w += !hard[i][j];
/* try(i,1,n)
{
try(j,1,m)
cout<<hard[i][j]<<' ';
cout<<endl;
}*/
try(cse,1,qnum)
{
io >> ex >> ey >> nowx >> nowy >> goalx >> goaly;
// sb(goalx); jb(goaly);
if(hard[goalx][goaly]) {puts("-1"); continue;}
int ans = 0;
while(!dfs(0,ex,ey,nowx,nowy,++ans))
{
// cout<<endl;
// if(ans == 2) break;
// if(ans > cnt_w) {puts("-1"); break;}
// jb(ans);
if(clock() > 0.4* CLOCKS_PER_SEC) {ans = -1; break;}
}
cout<<ans<<endl;
}
return 0;
}
}
signed main() {return xin::main();}
主要是這個玩意我不知道該如何判斷無解的情況。。
niuma兵
手動 @niuma兵
XIN* 算法
這個玩意實在不是很簡單。
所以只能口胡。
如果讓我們人腦完成一個搜索，那么我們一定會自動排除一些垃圾的狀態。
這樣的計算量會減少很多很多。
所以我們應該使計算機也有這個功能才好。
然后我們就可以設置強大的估價函數
這個玩意就是我們按照這個值的大小來決定我們的選擇順序。
這個估價函數設置成什么就得看自己的造化了。
然后每次把新搜索到的狀態扔到 priority_queue 里面就好了。