個人感覺是最短路大冒險……
（不知道為啥中暑了腦子反而活躍了起來，就是程式碼實現非常gg）

fzu 2253 Salty Fish
漁夫翻鹹魚，會把一個區間裡的1翻成0 0翻成1
區間長度至少為1
問最多有幾個1

統計原先的鹹魚數量
考慮每翻一次，如果本來是1 會使鹹魚數量-1，如果本來是0，會使鹹魚數量+1
所以把陣列更改為-1 +1
即陣列變為翻該魚會對總魚數的影響
然後求一個最大連續子序列和
最大值（翻身影響）+原來的魚數=最大魚數
但是因為至少要翻一條魚
所以特殊情況就是明明本來都是翻身的鹹魚，還一定要-1

#include <cstring>
 

#include <cmath>
#include <cstdio>
#include <iostream>

using namespace std;
const int maxn=100010;
#define eps 1e-8

int s[maxn],a[maxn];
int main()
{
int cases,i,j,ans,cnt,now,maxx,n;
 while (~scanf("%d",&n))
   {
    ans=0; cnt=0; now=0;
    memset(s,0,sizeof(s));
     for (i=1;i<=n;i++)
         {
            scanf
 
("%d",&a[i]);
            if (a[i]) ans++;
            if (i==1 || a[i]!=a[i-1]) cnt++;
         if (a[i]==0) s[cnt]++; else s[cnt]-=1;
         }

             maxx=0;
    for (i=1;i<=cnt;i++)
     {
     if (now+s[i]>0)  now+=s[i]; else now=0;
     maxx=max(maxx,now);
     }
    if (maxx)   printf
 
("%d\n",ans+maxx); else printf("%d\n",ans-1);

   }
   return 0;
}

比賽的時候……用了各種姿勢
最短路 拓撲 wa的死去活來
……後來發現最短路能ac 但是我忘記初始化了……

最短路能ac，但總感覺怪怪的

每個單詞一定存在的一種花費是len
或者從已經背誦的單詞轉移過來，需要的花費是hamming(Si, T) * w

用最短路的思路去更新，先記錄各個單詞之間轉移需要的花費
每次找需要花費最少的單詞進行背誦，然後更新未被背誦的單詞

#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <cstring>
#include <map>
#include <queue>
#include <algorithm>
#include <stack>
using namespace std;
const int maxn=1010;
const int INF=0x3f3f3f3f;
int len;
int n,mar[maxn][maxn],fin[maxn],dis[maxn];
int ind[maxn],vis[maxn];
vector<int>G[maxn];
void Dijkstr(int source)
{
    memset(fin,0,sizeof(fin));
    int i,j,minx,nextp;
    for (i=1;i<=n;i++)
    {
        fin[i]=0;
        dis[i]=mar[source][i];
    }
    fin[source]=1;
    dis[source]=0;
    for (i=2;i<=n;i++)
    {
        minx=INF;
        for (j=1;j<=n;j++)
            if (fin[j]==0 && dis[j]<minx)
            {
                minx=dis[j];
                nextp=j;
            }
        if (minx==INF) return;
        fin[nextp]=1;
        for (j=1;j<=n;j++)
            if (fin[j]==0 && mar[nextp][j]<dis[j])
                dis[j]=mar[nextp][j];
    }
}
char ss[maxn][15];
int main()
{
    int cases,m,u,v,w,sum,minn,mini;

    while (~scanf("%d%d%d",&n,&len,&w))
    {
        for (int i=1;i<=n;i++)
            {
                scanf("%s",ss[i]);
                G[i].clear();
                dis[i]=len;
            }
            memset(mar,0,sizeof(mar));

      minn=len; mini=1;
        for (int i=1;i<n;i++)
            for (int j=i+1;j<=n;j++)
            {
                mar[i][j]=len; sum=0;
                for (int k=0;k<len;k++)
                    if (ss[i][k]!=ss[j][k]) sum+=w;
                if (sum<len) mar[i][j]=sum;
                mar[j][i]=mar[i][j];
                if (mar[i][j]<minn) {mini=i; minn=mar[i][j]; }

            }
     Dijkstr(mini);
     sum=len;
     for (int i=1;i<=n;i++) sum+=dis[i];
     printf("%d\n",sum);
    }
    return 0;
}

過河

接下來n-1行，第i行包含兩個數字Pi和Wi，表示i+1號房間的上級房間為Pi，道路長度為Wi。
子節點和父節點之間的路是wi
也就是說任意兩點光靠走路其實都是相通的
每個房間擁有一個時空傳送門，第i個房間的傳送門可以花費Di單位的時間傳送到它的任意一個下級房間中（如果x是y的下級房間，並且y是z的下級房間，那麼x也是z的下級房間）
這裡意味著父節點都有傳送陣，可以傳送到任意子節點。
所以考慮把利用dfs把子節點都傳遞上來，建邊，花費d[i]
跑個最短路……輸出

比賽的時候瘋狂mle是因為模板裡有個判斷負環的陣列沒刪QAQ（這樣也行嘛）

#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <cstring>
#include <map>
#include <queue>
#include <algorithm>
#include <stack>
using namespace std;
const int maxn=100010;
const int INF=0x3f3f3f3f;
int dis[maxn],inq[maxn];
int n,d[maxn];

struct points
{
int v,w;
};
vector<points>G[maxn];
vector<int>son[maxn];
void add_edge(int u,int v,int w)
{
points now;
now.v=v;
now.w=w;
G[u].push_back(now);
}
void SPFA(int source)
{
  int u,v,w,i;
  memset(inq,0,sizeof(inq));
  for (i=0;i<=n+1;i++) dis[i]=INF;
    dis[source]=0;
    inq[source]=1;

  queue<int>q;
  points now;
  q.push(source);
  while (!q.empty())
  {
    u=q.front(); q.pop();
    inq[u]=0;
    for (i=0;i<G[u].size();i++)
    {
      v=G[u][i].v;
      w=G[u][i].w;
      if (dis[v]>dis[u]+w)
      {
        dis[v]=dis[u]+w;
        if (!inq[v])
        {
          inq[v]=1;
          q.push(v);
        }
      }
    }
  }
  return;
}
void dfs(int now)
{
int v,vv;
for (int i=0;i<son[now].size();i++)
{
dfs(son[now][i]);
}
int xx=son[now].size();
for (int i=0;i<xx;i++)
{
 v=son[now][i];
for (int j=0;j<son[v].size();j++)
{
vv=son[v][j];
son[now].push_back(vv);
add_edge(now,vv,d[now]);
}
}
return;
}
int main()
{
int cases,m,u,v,w,S;

while (~scanf("%d",&n))
{
    for (int i=1;i<=n;i++) { scanf("%d",&d[i]); G[i].clear(); son[i].clear();}
    for (int i=2;i<=n;i++)
    {
        scanf("%d%d",&u,&w);
        son[u].push_back(i);
        if (w<d[u]) add_edge(u,i,w); else add_edge(u,i,d[u]);
    }
    dfs(1);

    SPFA(1);
        for (int i=1;i<=n;i++) printf("%d ",dis[i]);
        printf("\n");
}
    return 0;
}

fzu 2258 獎勵
不能用除法……判斷總分>=240且單科都>=60就好了。

圖

浪裡個浪
多起點多終點最短路
把所有可能的起點和零點建邊，路程為0
把所有可能的終點和n+1點建邊，路程為0
跑一遍從0點開始的最短路，輸出到n+1這個點的最短路程
和hdu 2066類似
不過因為hdu那題資料小，……我跑了s遍最短路……emmmmm