[日記&作題記錄]-Noip2016提升組複賽倒數十天

時間 2019-11-09

標籤日記記錄 noip2016 noip 提升複賽倒數十天 10天简体版

原文原文鏈接

寫這篇博客的時候有點激動爲了讓本身不頹仍是寫寫日記存存模板php

Nov.8 2016node

今天早上買了兩個蛋撻吃了一個而後就作數論(前天晚上仍是想放棄數論可是昨天被數論虐了 woc noip模擬賽出了道杜教篩)ios

而後白天就腦補了幾道積性函數把例題過了一遍數組

Submit_Time
1696174	wohenshuai	2154	Accepted	245432 kb	10556 ms	C++/Edit	1152 B	2016-11-08 16:50:10
1695614	wohenshuai	1101	Accepted	1924 kb	8236 ms	C++/Edit	952 B	2016-11-08 10:59:57
1695536	wohenshuai	2005	Accepted	2952 kb	44 ms	C++/Edit	907 B	2016-11-08 09:54:44
1695489	wohenshuai	2226	Accepted	25708 kb	7532 ms	C++/Edit	952 B	2016-11-08 08:47:44

最後一題是比較中等的積性函數也就是昨天的數論只會O(Nlogn - N½) 作被虐傻了ide

sb數論廢了我十二張白紙真是感人肺腑固然還有兩題函數

總結能夠提出來的儘可能提而後$gcd(a,b)$ 變成 1 再莫比烏斯反演一下下而後還有一點小技巧記記就好測試

今天晚上睡覺前所有再推一遍大數據

哦對今天悟出了怎麼打分塊 .......................... 今天還學會了插數學公式可是全部推導要寫半天不寫了spa

晚上覆習了自動機dp 明天測試不要掛哇！3d

Nov.9 2016

早上測了一場感受noip難度差很少只是第二題略有點經典和sb 第三題優先隊列噁心就沒了

下午和晚上都作回沒有什麼能夠說的題目太噁心我太垃圾作的很不順

Nov.10 2016

早上下午寫了三道點分治基於昨天的比賽而後膨脹了一會

總結一點點分治要不就找什麼大於等於或者小於的點對要不就找等於k的點對反正簡單題都是這樣

早上還作了一道環套樹(noip 難度...) 把環去邊而後算這條邊的貢獻

還有一個就是點分治的題要出數據卡本身有沒有找錯重心(常常打少一些東西) 還有跑dfs的時候要判斷這個點有沒有被標記過，由於找完重心以後整個樹都是亂的，有可能傳進來的點在這個亂的樹的下面(只有我本身知道我在說什麼估計)

晚上寫了洛谷的一場比賽一題錯排一題twoset被虐的不知所措

1699489	wohenshuai	2152	Accepted	3340 kb	420 ms	C++/Edit	2043 B	2016-11-10 15:57:06
1699060	wohenshuai	3648	Accepted	23320 kb	4308 ms	C++/Edit	4089 B	2016-11-10 11:50:06

還有一些見hwzer blog上的..orzorz

Nov.11 2016

liao出的比賽好像有毒次次都不上100

第一題打了好久發現有個向下取整..而後刪掉暴力第二題也想錯了第三題水暴力第四題一秒不會作

而後下午就作回第四題表示沒力草

1701659	wohenshuai	3232	Accepted	27748 kb	4708 ms	C++/Edit	2694 B	2016-11-11 17:11:19
1701469	wohenshuai	4240	Accepted	8324 kb	1696 ms	C++/Edit	786 B	2016-11-11 16:09:31
1701326	wohenshuai	3211	Accepted	12912 kb	4224 ms	C++/Edit	1456 B	2016-11-11 15:26:27

按順序三二一晚上晚點到機房而後作洛谷的比賽感人肺腑一個小時的看題想題時間最後啥都不會

而後頹廢得把當年noip我只拿20分的題

Nov.12 2016

今天星期六本應回家的考慮到回家找不到生命的意義而後就在學校留宿了也頹了一天看了一下解憂的雜貨店或有點感觸

作的東西很少主要作了noip2011的day2

固然這是提交兩次以後的成績.. 第一題一眼數學題但不知道哪裏錯了兩個點第二題先寫了個可持久化線段樹爽了一下發現好像這是noip賽(原本想寫三分而後用兩個二分作了)

而後就發現主席樹查找logn提交60分而後發現掃一遍O(1)回答就能夠了.........無語了一天

第三題原本想打60分暴力打了又刪刪了又打真很吃力而後第一次隨便交0分後來改了一下才40分

仍是很弱沒打check就是沒底

總結一下作題要利索果斷而後想題要全面不怕麻煩不怕錯不要想蒙算時間要算準

第三題正解好像是哪裏省最多儘可能放這在看完題以後也有想到可是不知道哪裏纔算是省最多我太垃圾了

還有就是代碼寫的很不優美作題不夠淡定成天吃東西

Nov.13 2016

早上沒事幹寫了兩道題爽了一下下午寫了份洛谷的我的公開賽 305分圖包到手水了就算了

https://www.luogu.org/contest/show?tid=1189

簡單說一下:
A.線段樹裸題數組沒開大RE一次..

B.最小生成樹經典例題會作做業的再連個0點就好

C.首先是二分..而後呢就不知道該幹啥了 YY了一下字典序最小其實就是高度的字典序最小因此的話最優方案確定是二分後全部的值是單峯的否則的話能夠互相交換 (固然第一個和最後一個也要知足要求) 而後讓後面降低的幅度儘可能大前面上升的幅度儘可能小至關於在最小和最大的兩個數之間有兩條鏈一條最大能取就取一條取剩下的

這種作法跑的比標程還快.. 時間O(NlogH)

D.膜MT_Chan 這道題毫無頭緒 MT_Chan告訴我是經典DP 而後本身看錯題意媽的還誤導我..

而後本身手推了一下不知道爲何10分

說作法:先把x和y從小到大排序一下而後F[i][0.1.2]分別表示對於當前x來講沒有選x並且以前選了一條邊僅僅選了x這條邊除了選x還選了另一條邊

而後就wa了但也算有圖包

還寫了一下Noip2011的Day1 第三題不知道爲何官方數據我手動模擬都錯

第三題交了兩遍第一第二題1A

感受仍是有點弱

Nov.14 2016

剩下五天了實力太弱仍是有點慌

早上作了一場ljm比賽上場看到第一題以爲要死第二題好像是一年普及組的dp 可是增強了數據到了10^8..(我竟然想O(N).......也有想用容斥可是以前沒有本身獨立學過這個專題 0基礎) 第三題好像二分一下可持久化就能夠而後就寫了

而後二十分鐘不到寫完第三題感人肺腑一會兒過樣例出了組數據卡卡本身發現數組沒開大可是時間用了1.7s....

而後我跑去問男神出題人可不能夠開兩秒我寫的是log^2 他說他就是要卡log^2.........

感受要完

先看第二題先水了個四方暴力發現麻煩了降三方而後便祕去了不少趟廁所而後第一題感受能夠從下面到上面搞可是發現最下面那層最倒黴有N多個葉子節點感受很無奈看了一下

40%的數據好像最壞狀況也不能夠過首先打了個雙隊列發現反正都不能夠過寫個穩點的搜索

而後.........

第一題40%成功不知道爲何水過男神前4組數據都是那種最壞狀況的證實臉好

第二題30%正常過

第三題100%...最大數據0.8s 笑死我了

下午back回三題其實第三題感受很sb log^2和log寫的時間差很少題解也很無聊第二題容斥被虐傻第一題是從下到上搞發現每一個顏色都是同樣的而後記錄以前顏色的狀態也就是個數和整個樹的價值從下到上合併要求先序也就是從左到右就行了

第二題簡單說一下很經典就是用一個搜索來代替容斥把狀態不合法的塞進去搞一下固然考場上有想到就是狀態不合法的之後還有不合法的怎麼辦而遞歸的時候就把不合法的加回來..

也就是用了容斥的原理答案=全部狀態-不合法狀態+不合法狀態中本身自己沒法到達的不合法狀態......

至於下次能不能再想到這要看造化了

還有就是N個大於等於0的數和爲K的方案數爲C(N-1,N+K-1) 我本身不會推考場打表

晚上頹廢了一下..

Nov.15 2016

第三題有毒本機測試AC 而後交上去某vs某os洛谷全都掛了

個人還跑挺快的呢

個人第三題代碼

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<ctime>
using namespace std;
const int Maxn=14;
struct node
{
  int A[Maxn];
  node(){memset(A,0,sizeof(A));}
};

int G[20];

bool Dfs(int N,int K,int num,node X)
{
  if(K>N+1) return 0;
  if(num==0) return 1;
  
  int cnt=0; node Y;
  for(int i=0;i<=13;i++) if(X.A[i]>0) cnt++;
  if(cnt<=N-K+1) return 1;
  
  //Double
  for(int i=3;i<=12;i++)
  {
    int k=0; while(X.A[G[k+i]]>=2&&G[k+i]!=2) k++;
    if(k>=3)
    {
      Y=X;
      for(int j=i;j<i+k;j++) Y.A[G[j]]-=2;
      if(Dfs(N,K+1,num-k*2,Y)) return 1;
    }
  }
  
  //Single
  for(int i=3;i<=10;i++)
  {
    int k=0; while(X.A[G[k+i]]>=1&&G[k+i]!=2) k++;
    if(k>=5)
    {
      Y=X;
      for(int j=i;j<i+k;j++) Y.A[G[j]]-=1;
      if(Dfs(N,K+1,num-k,Y)) return 1;
    }
  }
  
  //Four+two+two
  for(int i=1;i<=13;i++)
  {
    if(X.A[i]==4)
    {
      for(int j=0;j<=13;j++) if(j!=i)
      {
        if(X.A[j]==3||X.A[j]<2) continue;
        for(int k=0;k<=13;k++) if(k!=i)
        {
          if(X.A[k]==3||X.A[k]<2) continue;
          if(j==k&&X.A[k]==2) continue;
          Y=X;
          Y.A[i]-=4; Y.A[j]-=2; Y.A[k]-=2;
          if(Dfs(N,K+1,num-8,Y)) return 1;
        }
      }
    }
  }
  
  //Four+one+one
  for(int i=1;i<=13;i++)
  {
    if(X.A[i]==4)
    {
      for(int j=0;j<=13;j++) if(j!=i)
      {
        if(X.A[j]>=3||X.A[j]==0) continue;
        for(int k=0;k<=13;k++) if(k!=i)
        {
          if(X.A[j]>=3||X.A[j]==0) continue;
          if(j==k&&X.A[k]==1) continue;
          Y=X;
          Y.A[i]-=4; Y.A[j]-=1; Y.A[k]-=1;
          if(Dfs(N,K+1,num-6,Y)) return 1;
        }
      }
    }
  }
  
  //Three+one or Three+two
  for(int i=1;i<=13;i++)
  {
    if(X.A[i]==3)
    {
      for(int j=0;j<=13;j++) if(j!=i)
      {
        if(X.A[j]>=3) continue;
        if(X.A[j]==1)
        {
          Y=X;
          Y.A[i]-=3; Y.A[j]-=1;
          if(Dfs(N,K+1,num-4,Y)) return 1;
        }
        if(X.A[j]==2)
        {
          Y=X;
          Y.A[i]-=3; Y.A[j]-=2;
          if(Dfs(N,K+1,num-5,Y)) return 1;
        }
      }
    }
  }
  
  //Triple
  for(int i=3;i<=13;i++)
  {
    int k=0; while(X.A[G[k+i]]>=3&&G[k+i]!=2) k++;
    if(k>=2)
    {
      Y=X;
      for(int j=i;j<i+k;j++) Y.A[G[j]]-=3;
      if(Dfs(N,K+1,num-k*3,Y)) return 1;
    }
  }

}

int main()
{
  freopen("landlords.in","r",stdin);
  freopen("landlords.out","w",stdout);
  int T,N; scanf("%d%d",&T,&N); for(int i=1;i<=15;i++) G[i]=(i>13?i-13:i);
  while(T--)
  {
    node ST; memset(ST.A,0,sizeof(ST.A));
    for(int i=1;i<=N;i++){int x,k; scanf("%d%d",&x,&k); ST.A[x]++;}
    
    // IDA*
    int L=1; int R=14; int ret;
    while(L<=R)
    {
      int mid=(L+R)>>1;
      if(Dfs(mid,1,N,ST)){ret=mid; R=mid-1;}
      else L=mid+1;
    }
    printf("%d\n",ret);
  }
  return 0;
}

View Code

固然我交上去是刪freopen的我叫一個管理員幫我看都不願...

第二題寫了個手工棧感人肺腑

算是AC了 noip2015 600強勢back回

晚上寫了一套題，調了調棧什麼的

發現這套題超水感受沒動過腦筋..

Nov.16 2016

死了還剩三天了怎麼辦呢？？

早上切了兩套題爽一下先

順帶說第一題有點噁心可能本身打很差就是能夠wifi到外面而我一開始打的是枚舉左下角而後吸收教訓了這樣枚舉可能中心在外面..

而後用矩陣差寫了之後這種題寫矩陣差

第三題方法鬼畜隨便找兩個質數判斷一下是否爲0就好這樣出現可能的概率很小由於兩個爲0不合法的只多是兩個質數公倍數..而後不知道爲何T了

第二題比較噁心轉來轉去第三題有點sb 今天碼速很快下午加油

下午作的題目好像有點強

第一題想了挺久的..雖然能夠遞歸過可是貪心很妙第三題噁心題遞歸題變最短路有點妙

晚上還寫回了上次比賽的D題

明天和後天早上要作開車和疫情而後複習割點割邊強連通奶牛配 KMP EXKMP 自動機後綴數組(雖說提升組範圍沒有後綴數組..) 優先隊列單調隊列 (區間最大最小值) two-set

剩下就是usaco的題表選一些經典再寫一下

Nov.17

今天不知道是效率低下仍是怎樣寫題好吃屎寫了開車和看病

看病最後一個點表示無力卡常好無聊看病這道題比較強首先通常很難直接獲得最優解就二分而後拼命往上跳跳完再分配下來

分配下來的時候通常來講是大對大的但是有從一個子樹上來的點能夠回到那個子樹因此貪心

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<vector>
using namespace std;
typedef long long LL;
const LL Maxn=50010;
struct node
{
  LL x,y,next,d;
}edge[Maxn*2]; LL len,first[Maxn];
void ins(LL x,LL y,LL d){len++; edge[len].x=x; edge[len].y=y; edge[len].d=d; edge[len].next=first[x]; first[x]=len;}
LL N,M; LL fa[Maxn][21]; LL dis[Maxn][21];
void Dfs(LL x)
{
  for(LL k=first[x];k!=-1;k=edge[k].next)
  {
    LL y=edge[k].y;
    if(y!=fa[x][0]){fa[y][0]=x; dis[y][0]=edge[k].d; Dfs(y);}
  }
}
void Pre()
{
  for(LL j=1;j<=20;j++)
    for(LL i=1;i<=N;i++)
    {
      fa[i][j]=fa[fa[i][j-1]][j-1];
      if(fa[i][j]) dis[i][j]=dis[fa[i][j-1]][j-1]+dis[i][j-1];
    }
}

bool bo[Maxn]; LL id[Maxn];
vector<pair<LL,LL> >res,need; //first=val second=id
LL match[Maxn];

bool Cover(LL x)
{
  if(bo[x]) return 1; bool bk=1; LL cnt=0;
  for(LL k=first[x];k!=-1;k=edge[k].next)
  {
    LL y=edge[k].y;
    if(y!=fa[x][0]){bk&=Cover(y); cnt++;}
  }
  if(cnt==0) return false;
  return bk;
}

bool Cmp(const pair<LL,LL> &x,const pair<LL,LL> &y){return x.first>y.first;}

LL Bet[Maxn],Q[Maxn];

bool Check(LL D)
{
  memset(bo,0,sizeof(bo)); res.clear(); need.clear();
  for(LL k=1;k<=M;k++)
  {
    LL i=id[k]; LL x=D;
    for(LL j=20;j>=0;j--)
    {
      if(x>=dis[i][j]&&fa[i][j]!=1) x-=dis[i][j],i=fa[i][j];
    }
    if(x>=dis[i][0]&&fa[i][0]==1) res.push_back(make_pair(x-dis[i][0],i));
    else bo[i]=1;
  }
  
  for(LL k=first[1];k!=-1;k=edge[k].next)
  {
    LL y=edge[k].y;
    if(!Cover(y))
      need.push_back(make_pair(edge[k].d,y));
  }
  
  sort(res.begin(),res.end(),Cmp);
  sort(need.begin(),need.end(),Cmp);
  memset(match,-1,sizeof(match));
  memset(Bet,-1,sizeof(Bet));
  memset(Q,-1,sizeof(Q));
  
  for(LL i=0;i<need.size();i++) Q[need[i].second]=i;
  for(LL i=0;i<res.size();i++)
  {
    if(Q[res[i].second]!=-1)
    {
      if(match[Q[res[i].second]]==-1) Bet[i]=Q[res[i].second],match[Q[res[i].second]]=i;
      else Bet[match[Q[res[i].second]]]=-1,match[Q[res[i].second]]=i,Bet[i]=Q[res[i].second];
    }
  }
  
  LL j=0;
  for(LL i=0;i<res.size();i++)
  {
    while(match[j]!=-1&&j<need.size()) j++;
    if(j==need.size()) return true;
    if(Bet[i]==-1)
    {
      if(res[i].first>=need[j].first){match[j]=i; j++;}
      else return false;
    }
    else if(j<Bet[i]){match[Bet[i]]=-1; Bet[i]=j; match[j]=i; j++;}
  }
  while(match[j]!=-1&&j<need.size()) j++;
  if(j==need.size()) return true;
  else return false;
}
int main()
{
  scanf("%lld",&N); len=0; memset(first,-1,sizeof(first));
  for(LL i=1;i<N;i++){LL x,y,d; scanf("%lld%lld%lld",&x,&y,&d); ins(x,y,d); ins(y,x,d);}
  memset(dis,126,sizeof(dis)); Dfs(1); Pre(); memset(bo,0,sizeof(bo));
  scanf("%lld",&M);
  for(LL i=1;i<=M;i++) scanf("%lld",&id[i]);
  LL L=0,R=1e9*N; LL ret=-1;
  while(L<=R)
  {
    LL mid=(L+R)>>1;
    if(Check(mid)) R=mid-1,ret=mid;
    else L=mid+1;
  }
  return printf("%lld\n",ret),0;
}