咸鱼烤前的垂死挣扎

敲黑板当当当~ 

从今晚（28）起，日更 “咸鱼烤前的垂死挣扎”。

日更的内容是对当天学习的模板做一个小小的总结

日更的的口号是——

　　　　　　　　　　不是还没到最后一刻嘛~

　　　　　小哥哥再坚持一下嘛~ 

---

搜索

P1379 八数码难题

题面：

在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。

思路：

隐形图要做转化处理（压缩，解压），然后就是跑上一圈BFS啦~

注意特判(＾Ｕ＾)ノ~ＹＯ

（听说还可以用康托展开处理，待我学会去去就来~）

#include<cstdio>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;

struct node{
    string s;
    int step;
}a,e;
int sum,ans,tot;
int dx[4]={-1,0,0,1},dy[4]={0,1,-1,0};
char b[3][3];
string n,m;
bool flag[88888888];
queue <node > q;

string change(){
    string c;
    sum=0;
    for(int i=0;i<3;i++)
        for(int j=0;j<3;j++){
            c+=b[i][j];
            if(!(i==2&&j==2))sum=sum*10+b[i][j]-'0';    //注意求的是前 8位的和 
        }
    return c;
}

void bfs(){
    while(!q.empty()){
        int tot=0,x,y;
        a=q.front();
        q.pop();
        for(int i=0;i<3;i++)        // 解压 
            for(int j=0;j<3;j++){
                if(a.s[tot]=='0') x=i,y=j;
                b[i][j]=a.s[tot++];
            }
        for(int i=0;i<4;i++){        // 四个方向扫一遍 
            if(x+dx[i]>-1&&x+dx[i]<3&&y+dy[i]>-1&&y+dy[i]<3){
                swap(b[x][y],b[x+dx[i]][y+dy[i]]);
                e.s=change();    // 压缩->字符串 
                if(e.s=="123804765"){
                    printf("%d",a.step+1);
                    exit(0);
                }
                if(!flag[sum]){
                    flag[sum]=1;
                    e.step=a.step+1;
                    q.push(e);
                    
                }
                swap(b[x][y],b[x+dx[i]][y+dy[i]]);    //回溯 
            }
        }
    }
}
    
int main()
{
    cin>>n;
    m="123804765";
    a.s=n,a.step=0;
    q.push(a);
    for(int i=0;i<8;i++) sum=sum*10+n[i]-'0';
    for(int i=0;i<8;i++) ans=ans*10+m[i]-'0';
    flag[sum]=1;
    
    if(sum==ans) printf("0");    //注意特判 
    else bfs();
    
    return 0;
}

 继续练我可怜的广搜！

P2296 寻找道路

题面：

在有向图 G 中，每条边的长度均为 1，现给定起点和终点，请你在图中找一条从起点到终点的路径，该路径满足以下条件：

1. 1. 路径上的所有点的出边所指向的点都直接或间接与终点连通。
   2. 在满足条件1的情况下使路径最短。

注意：图 G 中可能存在重边和自环，题目保证终点没有出边。

思路：

　　1.  从终点反向BFS，求出所有可以到达终点的点 　　available[]

　　2.  对每个点判断是否自己指向的节点都可以到达终点　　ans[]

　　3.  从起点正向BFS，求最短路

总结：

　　未知的起点，确定的终点。反向跑图。

#include<cstdio>
#include<queue>
#include<vector>
#define N 10010
using namespace std;
int read(){
    int x=0,f=1; char c=getchar();
    while(c<'0'||c>'9') {if(c=='-') f=-1; c=getchar();}
    while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
    return f*x;
}
int n,m,s,t;
int ava[N],ans[N],dis[N];//available
queue < int > q;
vector < int > cd[N];
vector < int > rd[N];
int main()
{
    n=read(),m=read();
    for(int x,y,i=1;i<=m;i++){
        x=read(),y=read();
        rd[y].push_back(x);
        cd[x].push_back(y);
    }
    s=read(),t=read();
    ava[t]=1,q.push(t);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=0;i<rd[u].size();i++){
            int v=rd[u][i];
            if(!ava[v]){
                ava[v]=1;
                q.push(v);
            }
        }
    }
    if(!ava[s]){ 
        printf("-1"); return 0;
    }
    for(int i=1;i<=n;i++){
        if(ava[i]){
            int k=0;
            for(int j=0;j<cd[i].size();j++){
                if(!ava[cd[i][j]]){
                    k=1;
                    break;
                }
            }
            if(k==0) ans[i]=1;
        }
    }
    dis[s]=1,q.push(s);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        if(u==t){
            printf("%d",dis[t]-1);
            return 0;
        }
        for(int i=0;i<cd[u].size();i++){
            int v=cd[u][i];
            if(ans[v]&&!dis[v]){
                dis[v]=dis[u]+1;
                q.push(v);
            }
        }
    }
    return 0;
}

DP

• 区间DP

使用特征： 每次可以消去一个区间，之后左右两边会合并起来。具有最优子问题结构且状态满足无后效性。

解法： 先枚举  区间长度 / 操作次数 ， 再枚举  左端点 / 起始位置 ， 后枚举  区间断点 / 结束位置  进行转移。

（一）  czy把妹　　　（见模拟赛篇）

 

 （二） 能量项链

题面：

在Mars星球上，每个Mars人都随身佩带着一串能量项链。在项链上有NN颗能量珠。能量珠是一颗有头标记与尾标记的珠子，这些标记对应着某个正整数。并且，对于相邻的两颗珠子，前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样，通过吸盘（吸盘是Mars人吸收能量的一种器官）的作用，这两颗珠子才能聚合成一颗珠子，同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为m，尾标记为r，后一颗能量珠的头标记为r，尾标记为n，则聚合后释放的能量为m×r×n（Mars单位），新产生的珠子的头标记为m，尾标记为n。

需要时，Mars人就用吸盘夹住相邻的两颗珠子，通过聚合得到能量，直到项链上只剩下一颗珠子为止。显然，不同的聚合顺序得到的总能量是不同的，请你设计一个聚合顺序，使一串项链释放出的总能量最大。

 

特别注意：

并未要求按顺序合并，事实说明按顺时针方向摆放珠子，合并时可以选择任意相邻的两个珠子合并，只要总能量最大即可。

#include<cstdio>
#include<algorithm>
#define re register
#define in inline
#define N 2000
using namespace std;
int read(){
    int x=0,f=1; char c=getchar();
    while(c<'0'||c>'9') {if(c=='-') f=-1; c=getchar();}
    while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
    return x*f;
}
int n,ans;
int head[N],tail[N],f[N][N];
int main()
{
    n=read();
    for(re int i=1;i<=n;i++) head[i]=head[n+i]=read();
    for(re int i=1;i<=n;i++) tail[i]=tail[n+i]=head[i+1];
    tail[n]=tail[2*n]=head[1];
    
    for(int t=1;t<=n-1;t++)　　//合并次数
        for(int i=1;i<=2*n-t;i++){　　//起始位置
            int j=i+t;　　//计算结束位置
            for(int k=i;k<=j-1;k++)　　//决策
                f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]+head[i]*tail[k]*tail[j]);
        }
    for(int i=1;i<=n;i++)
        ans=max(ans,f[i][i+n-1]);
    printf("%d",ans);
    return 0;
}

---

总结一些数论小板子：

• 快速幂

ll ksm(ll a,ll b,int mod){
    ll ret=1;
    while(b){
        if(b&1) ret=ret*a%mod;　　// b&1 表示 b在二进制下最后一位是1
        a=a*a%mod;
        b>>=1;
    }
    return ret;
}

• 裴蜀定理

问题： 给出n个数(A1...An) 现求一组整数序列(X1...Xn) 使得 S=A1X1+...AnXn>0, 且S的值最小

解法： ax+by=c,x∈N+,y∈N+ 成立的充要条件是 gcd(a,b) | c 

#include<cstdio>
using namespace std;
int ans;
int gcd(int a,int b){
    return !b ?a : gcd(b,a%b);
}
int main()
{
    int n,m;
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&m);
        m=(m>0)?m:-m;       //数据中有负数，要将其变为正数再求gcd
        ans=gcd(ans,m);
    }
    printf("%d
", ans);
    return 0;
}

 

---

  无线通讯网【最小生成树】

题意：

他们相距多远。而只通过无线电收发器通话的哨所之间的距离不能超过 D，这是受收发器的功率限制。收发器的功率越高，通话距离 D 会更远，但同时价格也会更贵。

收发器需要统一购买和安装，所以全部哨所只能选择安装一种型号的收发器。换句话说，每一对哨所之间的通话距离都是同一个 D。你的任务是确定收发器必须的最小通话距离 D，使得每一对哨所之间至少有一条通话路径（直接的或者间接的）。

思路：

做本题首先应该知道一共有p个点就是树有p-1条边，有s个卫星电话就是不用连接最大的s-1条边。

求树中前（p-s）条边里的最大边即可。

#include<cstdio>
#include<cmath>
#include<algorithm>
#define re register
#define in inline
#define ll long long
#define N 250010
using namespace std;
in int read(){
    int x=0,f=1; char c=getchar();
    while(c<'0'||c>'9'){if(c=='-') f=-1; c=getchar();}
    while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
    return x*f;
}

struct node{
    int u,v;
    double w;
}edge[N];
int s,p,cnt,tot,fa[N],px[N],py[N];

int getfather(int x){
    if(x==fa[x]) return x;
    return fa[x]=getfather(fa[x]);
}

in bool cmp(node x,node y){
    return x.w<y.w;
}

double solve(int i,int j){
    double dis=(double)sqrt((px[i]-px[j])*(px[i]-px[j])+(py[i]-py[j])*(py[i]-py[j]));
    return dis;
}

void kruskal(){
    sort(edge+1,edge+1+cnt,cmp);
    for(re int i=1;i<=cnt;i++){
        int x=getfather(edge[i].u);
        int y=getfather(edge[i].v);
        if(x==y) continue;
        fa[y]=x;
        if(++tot==p-s){
            printf("%.2lf",edge[i].w);
            exit(0);
        }
    }
}

int main()
{
    s=read(),p=read();
    for(re int i=1;i<=p;i++) px[i]=read(),py[i]=read();
    for(re int i=1;i<=p;i++) fa[i]=i;
    for(re int i=1;i<p;i++)
        for(re int j=i+1;j<=p;j++){
            double dis=solve(i,j);
            cnt++;
            edge[cnt].u=i,edge[cnt].v=j,edge[cnt].w=dis;
        }
    kruskal();
    return 0;
}