第2周周记（9月18日-9月24日）

---

过河

题目描述：

有N个人想要过一条河，但是他们只有一条最多载两人的船。因此必须想出一个调度船来回的方法让每个人都能过河。每个人都有自己的划船速度，且同一条船上的两个人取决于慢者的速度。你的任务就是想出一个每人都能过河的最快策略。

输入格式:

输入的第一行是一个正整数T(1 <= T <= 20),表示测试用例的组数。下面是T组用例。每个用例的第一行是正整数N，第二行是N个正整数表示每个人的划船速度。每组用例不会超出1000个人，每个人的划船时间不会超过100秒。

输出格式:

对于每个用例，输出所有N个人都能过河的最短时间（秒）。

输入样例:

2
3
1 3 7
4
1 2 5 10

输出样例:

11
17

分析：

我们考虑把单独过河所需要时间最多的两个旅行者送到对岸去，有两种方式：
1.最快的和次快的过河，然后最快的将船划回来；次慢的和最慢的过河，然后次快的将船划回来，所需时间为：

a[1]+2*a[2]+a[n]；

2.最快的和最慢的过河，然后最快的将船划回来，最快的和次慢的过河，然后最快的将船划回来，所需时间为：

2*a[1]+a[n-1]+a[n]。

（这里我们考虑这两种方式的原因，主要是船能乘2人，应该尽量想办法把最慢的两人先送过去，保证最后一定是最快就和次快的人到对岸。这就有两种，一是只有最快的人回来，次快的在岸上等；二是最快和最慢的人都回来一次，也就是第一次先把次快的送过去，倒数第二次，次快的再回来和最快的一起过去。）

代码

#include <bits/stdc++.h>

using namespace std;
int a[1005];

int cross(int n,int a[]){
    if(n==0)
        return 0;
    if(n==1)
        return a[1];
    if(n==2)
        return a[2];
    if(n==3)
        return a[1] + a[2] + a[3];
    else{
        int t1 = a[n] + a[1] + a[n - 1] + a[1]; // 最快的和最慢的过河，然后最快的将船划回来，最快的和次慢的过河，然后最快的将船划回来
        int t2 = a[2] + a[1] + a[n] + a[2]; // 最快的和次快的过河，然后最快的将船划回来；次慢的和最慢的过河，然后次快的将船划回来
        int tmax=min(t1,t2);
        return tmax + cross(n - 2, a);//循环一次岸边少了两个人
    }
}
int main()
{
    int t;
    cin >> t;
    while(t--){
        int n;
        cin >> n;
        memset(a, 0, sizeof(a));//归零
        for (int i = 1; i <= n;i++){
            cin >> a[i];
        }
        sort(a + 1, a + n + 1);//排序
        cout << cross(n, a) << endl;
    }

    return 0;
}

复杂度：O（n）

321

分析：

将1-n之间的类似于321的数（即3>2>1）列出来，寻找第k个符合条件的数字

代码

#include <bits/stdc++.h>
using namespace std;
int main()
{
    vector<long long> ans;
    for (int i = 2; i < (1 << 10)/*2的10次方*/; i++)
    {
        long long x = 0;
        for (int j = 9; j >= 0; j--)
        {
            if (i & (1 << j)) // i & (1<<j)则表示 i 和 1<<j（即2^j） 按位与后得到的数。1<<j的二进制表示只有第j个位置（从右往左数，从0开始）上的数是1，其余位置上的数是0，i和1<<j 进行按位与操作时，i的第j个位置是1就返回1<<j（判断语句中即为true），i的第j个位置是0就返回0（判断语句中即为false）。
                {
                    x *= 10;
                    x += j;
                }
        }
        ans.push_back(x);
    }
    sort(ans.begin(), ans.end());
    int k;
    cin >> k;
    cout << ans[k - 1] << "\n";
    return 0;
}

复杂度：O（n*n）

i&（1＜＜j）

i & (1<<j)则表示 i 和 1<<j（即2^j） 按位与后得到的数。1<<j的二进制表示只有第j个位置（从右往左数，从0开始）上的数是1，其余位置上的数是0，i和1<<j 进行按位与操作时，i的第j个位置是1就返回1<<j（判断语句中即为true），i的第j个位置是0就返回0（判断语句中即为false）。

迷宫-广度策略

题目描述

一个陷入迷宫的老鼠如何找到出口的问题。老鼠希望系统性地尝试所有的路径之后走出迷宫。如果它到达一个死胡同，将原路返回到上一个位置，尝试新的路径。在每个位置上老鼠可以向八个方向运动，顺序是从正东开始按照顺时针进行。无论离出口多远，它总是按照这样的顺序尝试，当到达一个死胡同之后，老鼠将进行“回溯”。迷宫只有一个入口，一个出口，设计程序要求输出迷宫的一条通路。迷宫采用二维存储结构表示，1表示障碍，0表示通路；要求如下： 1、实现队列的相关操作； 2、利用队列进行广度策略搜索算法输出路径；

输入格式:

输入包括三部分： 第一个输入是迷宫大小；第二个输入是迷宫的状态；第三个输入是入口和出口位置

输出格式:

反向输出探索的路径，注意包括入口和出口位置。每个位置之间用分号;分隔。

输入样例:

9
1 1 1 1 1 1 1 1 1
1 0 0 1 1 0 1 1 1
1 1 0 0 0 0 0 0 1
1 0 1 0 0 1 1 1 1
1 0 1 1 1 0 0 1 1
1 1 0 0 1 0 0 0 1
1 0 1 1 0 0 0 1 1
1 1 1 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1
1 1 7 7

输出样例:

7 7;6 6;5 6;4 5;3 4;2 3;1 2;1 1;

分析

从起点开始，向8个方向试探，碰到障碍就返回，没有障碍就一直走，最终选择一条最优路线输出。

代码

#include <bits/stdc++.h>

using namespace std;

int dir[][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}};

int a[30][30], vis[30][30];
int sx, sy, ex, ey, step, n, t = 100000;

struct pos
{
    int x, y;
};

pos best[105], trace[105];

void dfs(int x, int y, int step)
{
    if (x == ex && y == ey)
    {
        if (step < t) // 保证倒着输出
        {
            t = step;
            for (int i = 0; i < step; i++)
            {
                best[i] = trace[i];
            }
        }
        return; // 结束
    }
    for (int i = 0; i < 8; i++)
    {
        int nx = x + dir[i][0];
        int ny = y + dir[i][1];
        if (nx < 1 || nx > n || ny < 1 || ny > n || a[nx][ny])
            continue;
        if (!vis[nx][ny])
        {
            vis[nx][ny] = 1;
            trace[step].x = nx;
            trace[step].y = ny;
            dfs(nx, ny, step + 1); // 回溯
            vis[nx][ny] = 0;
        }
    }
    return;
}

int main()
{

    cin >> n;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cin >> a[i][j];
        }
    }
    cin >> sx >> sy;
   cin>> ex >> ey;
    vis[sx][sy] = 1;
    dfs(sx, sy, 1);
    for (int i = t - 1; i > 0; i--)
    {
        cout << best[i].x << " " << best[i].y << ";";
    }
    cout << sx << " " << sy << ";";
}

复杂度：O（n*n）