首先是这周主要是做搜索啊模拟啊什么的，感觉没有找到什么能写的东西，但是现在困得不行，也不想闲着，就找了一题来记一下。

P1514 引水入城

这个题是搜索＋动规，思路是用搜索找到湖边的每一个点到沙漠边能覆盖几座城，这是一个线段覆盖，那么问题就转换成了凭每个线段覆盖的范围找出最少需要的线段数量，那么就交给dp来完成。
思路有了，接下来就是实现，这也是我为什么记下这题的原因，题解里有一篇手写队列的广搜写法，我觉得是值得借鉴的，甚至可以当作学习样本。

void BFS(int sx, int sy)            //开始了，手写队列，sx和sy表示s初始位置的坐标
{
    memset(vis, 0, sizeof(vis));			//初始化
    if(n==1)					//如果只有一行城市，那么首先自己能到的范围包括自己，并立flag
    {
        a[sy].l = sy;
        a[sy].r = sy;
        flag[sy] = 1;
    }
    vis[sx][sy] = 1;
    start = 1, ending = 2;      //初始化队首，队尾
    gkd[1].x = sx, gkd[1].y = sy;
    while(start < ending)
    {
        FOR(i, 0, 3)					//上下左右四个方向走
        {
            int nx = gkd[start].x + dx[i];
            int ny = gkd[start].y + dy[i];
            if(Map[nx][ny] < Map[gkd[start].x][gkd[start].y] && vis[nx][ny]==0)
            {
                if(nx >= 1 && nx <= n && ny >= 1 && ny <= m)
                {
                    if(nx == 1)         //下一步在第一行
                        a[ny].vis = 0;      //标记首行两元素能被连通
                    if(nx == n)         //下一步在最后一行
                    {
                        a[sy].l = min(a[sy].l, ny);         //更新当前sy能去到最远的地方
                        a[sy].r = max(a[sy].r, ny);
                        flag[ny] = 1;           //表示ny能被届到，立flag
                    }
                    gkd[ending].x = nx;
                    gkd[ending].y = ny;         //更新队尾的位置
                    vis[nx][ny] = 1;
                    ending++;			//下一个队列元素
                }
            }
        }
        start++;        //更新队首序号
    }
}

然后贴一下全代码吧，其实也就多了主函数和dp函数，注释说话

#include<bits/stdc++.h>
#define maxn 505
#define maxm 1000005
#define FOR(a, b, c) for(int a=b; a<=c; a++)
#define hrdg 1000000007
#define inf 2147483647
#define llinf 9223372036854775807
#define ll long long
#define pi acos(-1.0)
#define ls p<<1
#define rs p<<1|1
using namespace std;

int n, m, cnt, start, ending;
int vis[maxn][maxn], Map[maxn][maxn];    //走图用数组
int f[maxn][maxn], dp[maxn];        //dp用数组
int flag[maxn];             //标记能不能到
int dx[5] = {1, 0, -1, 0};
int dy[5] = {0, -1, 0, 1};  //方向数组
struct node1
{
    int l, r, vis;
} a[maxn];              //记录当前点最左最右能去到哪
struct node2
{
    int x, y;
} gkd[maxm];            //队列数组

inline int read()
{
    char c=getchar(); long long x=0,f=1;
    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;
}

void BFS(int sx, int sy)            //开始了，手写队列
{
    memset(vis, 0, sizeof(vis));
    if(n==1)
    {
        a[sy].l = sy;
        a[sy].r = sy;
        flag[sy] = 1;
    }
    vis[sx][sy] = 1;
    start = 1, ending = 2;      //初始化队首，队尾
    gkd[1].x = sx, gkd[1].y = sy;
    while(start < ending)
    {
        FOR(i, 0, 3)
        {
            int nx = gkd[start].x + dx[i];
            int ny = gkd[start].y + dy[i];
            if(Map[nx][ny] < Map[gkd[start].x][gkd[start].y] && vis[nx][ny]==0)
            {
                if(nx >= 1 && nx <= n && ny >= 1 && ny <= m)
                {
                    if(nx == 1)         //下一步在第一行
                        a[ny].vis = 0;      //标记首行两元素能被连通
                    if(nx == n)         //下一步在最后一行
                    {
                        a[sy].l = min(a[sy].l, ny);         //更新当前sy能去到最远的地方
                        a[sy].r = max(a[sy].r, ny);
                        flag[ny] = 1;           //表示ny能被届到
                    }
                    gkd[ending].x = nx;
                    gkd[ending].y = ny;         //更新队尾的位置
                    vis[nx][ny] = 1;
                    ending++;
                }
            }
        }
        start++;        //更新队首序号
    }
}

void dp_dtmd()
{
    FOR(j, 1, m)        //初始化dp数组
    {
        dp[j] = inf/10;
        FOR(i, 1, m)
        f[i][j] = inf/10;
    }
    FOR(k, 1, m)
    if(a[k].r != 0)
        FOR(i, a[k].l, a[k].r)
        FOR(j, i, a[k].r)
    {
        f[i][j] = 1;
        if(i==1)    //如果左边界就是1，那么前缀j直接更新
            dp[j] = 1;
    }
    FOR(i, 1, m)            //dp找到前m个最少需要的水厂
    FOR(j, 1, i-1)
    dp[i] = min(dp[i], dp[j]+f[j+1][i]);
}

int main()
{
    n = read();
    m = read();
    FOR(i, 1, n)
    FOR(j, 1, m)
    Map[i][j] = read();
    FOR(i, 1, m)        //初始化
    {
        a[i].l = inf/10;        //我不知道为什么，直接拿inf初始化会爆栈
        a[i].r = 0;
        a[i].vis = 1;
        flag[i] = 0;
    }
    FOR(i, 1, m)
    if(a[i].vis)     //之后在bfs过程中出现首行元素和另一个首行元素相连，那么之后没必要再去搜索另一个
        BFS(1, i);
    FOR(i, 1, m)         //检索有多少没能够到的
    if(flag[i]==0)
        cnt++;
    if(cnt!=0)              //如果有，输出并结束总程序
    {
        printf("0\n%d", cnt);
        exit(0);
    }
    dp_dtmd();
    printf("1\n%d", dp[m]);
    return 0;
}

其实这题除了手写队列值得学习之外，我还发现最近遇到的很多搜索题都会跟dp挂上钩，之后好好学dp吧呕……