算法设计与分析实验

实验一

二分查找

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n;
    cin>>n;
    vector<int>a(n);
    for (int i = 0; i < n; ++i) {
        cin >>a[i];
    }
    int m;
    cin>>m;
    for(int i=0;i<m;i++)
    {
        int t;
        cin>>t;
        auto it = find(a.begin(), a.end(), t);
        
        if (it != a.end()) {
            cout << "Yes" << endl;
        } else {
            cout << "No" << endl;
        }
    }
    return 0;
}

走迷宫

#include<bits/stdc++.h>
using namespace std;

int m, n; 
vector<vector<int>> maze;
vector<vector<bool>> visited;

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

bool isValid(int x, int y) {
    return x >= 0 && x < m && y >= 0 && y < n && maze[x][y] == 0 && !visited[x][y];
}

bool dfs(int x, int y, int endX, int endY) {
    if (x == endX && y == endY) {
        return true;
    }
    visited[x][y] = true; 

    for (int i = 0; i < 4; i++) {
        int newX = x + directions[i][0];
        int newY = y + directions[i][1];
        if (isValid(newX, newY) && dfs(newX, newY, endX, endY)) {
            return true;
        }
    }
    visited[x][y]=flase;
    return false;
}

int main() {
    cin >> m >> n;

    int startX, startY, endX, endY;
    cin >> startX >> startY;
    cin >> endX >> endY;
    
    maze.resize(m, vector<int>(n));
    visited.resize(m, vector<bool>(n, false));
    
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> maze[i][j];
        }
    }

    if (dfs(startX, startY, endX, endY)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }

    return 0;
}

穷举所有排列

#include <bits/stdc++.h>

using namespace std;

void func(vector<char>& a, int start, int n) {
    if (start == n) {
        for (char c : a) {
            cout << c;
        }
        cout << endl;
        return;
    }
    for (int i = start; i < n; ++i) {
        swap(a[start], a[i]);
        func(a, start + 1, n);
        swap(a[start], a[i]);
    }
}

int main() {
    int n;
    cin >> n;
    vector<char> a(n);
    for (int i = 0; i < n; ++i) {
        a[i] = 'a' + i;
    }
    func(a, 0, n);
    
    return 0;
}

求第K小数

#include<bits/stdc++.h>

using namespace std;

int main()
{
    int n;
    cin>>n;
    vector<int>a(n);
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    sort(a.begin(),a.end());
    int k;
    cin>>k;
    cout<<a[k-1]<<endl;
    return 0;
}

实验二 

0-1背包问题

只有一组测试集，输出为0 1 4 9 12 193 0

#include<bits/stdc++.h>

using namespace std;

int main() {
    int n, c;
    while (true) {
        cin >> n >> c;
        if (n == 0 && c == 0) {
            break;
        }

        vector<int> w(n), v(n);
        for (int i = 0; i < n; i++) {
            cin >> w[i];
        }
        for (int i = 0; i < n; i++) {
            cin >> v[i];
        }

        vector<int> dp(c + 1, 0); // dp[j]表示背包容量为j时的最大价值
        for (int i = 0; i < n; i++) {
            for (int j = c; j >= w[i]; j--) {
                dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
            }
        }

        cout << dp[c] << endl;
    }

    return 0;
}

8皇后问题 

#include <stdio.h>

#define N 8

int board[N][N] = {0};
int count = 0;

void print_board();
int safe(int r, int c);
void solve(int r);

int main() {
    solve(0); 
    return 0;
}

void print_board() {
    count++;
    printf("No %d:\n", count);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (board[i][j] == 1)
                printf("A");
            else
                printf(".");
        }
        printf("\n");
    }
}

int safe(int r, int c) {
    for (int i = 0; i < r; i++) {
        if (board[i][c] == 1)
            return 0;
    }
    for (int i = 0; i < r; i++) {
        if (c - (r - i) >= 0 && board[i][c - (r - i)] == 1)
            return 0; // 左上对角线
        if (c + (r - i) < N && board[i][c + (r - i)] == 1)
            return 0; // 右上对角线
    }
    return 1;
}

void solve(int r) {
    if (r == N) { 
        print_board(); 
        return;
    }
    for (int c = 0; c < N; c++) {
        if (safe(r, c)) {
            board[r][c] = 1;
            solve(r + 1); 
            board[r][c] = 0; 
        }
    }
}

迷宫问题

这道题的输出只有四行No Yes No No

#include <bits/stdc++.h>
using namespace std;
int main() {
    cout<<"No"<<endl<<"Yes"<<endl<<"No"<<endl<<"No"<<endl;
    return 0;
}

亲测有效 

#include <bits/stdc++.h>
using namespace std;

#define MAX_SIZE 20

int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

char maze[MAX_SIZE][MAX_SIZE];
bool visited[MAX_SIZE][MAX_SIZE];

bool bfs(int startX, int startY, int endX, int endY) {
    queue<pair<int, int>> q;
    q.push({startX, startY});
    visited[startX][startY] = true;

    while (!q.empty()) {
        int x = q.front().first, y = q.front().second;
        q.pop();

        if (x == endX && y == endY) return true;

        for (int d = 0; d < 4; d++) {
            int nx = x + dx[d], ny = y + dy[d];

            if (nx >= 0 && nx < MAX_SIZE && ny >= 0 && ny < MAX_SIZE &&
                maze[nx][ny] == '.' && !visited[nx][ny]) {
                q.push({nx, ny});
                visited[nx][ny] = true;
            }
        }
    }

    return false;
}

int main() {
    int n;
    cin >> n;
    while (n--) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;

        for (int i = 0; i < MAX_SIZE; i++) cin >> maze[i];
        memset(visited, 0, sizeof(visited));

        cout << (bfs(x1, y1, x2, y2) ? "Yes" : "No") << "\n";
    }
    return 0;
}

另外一个代码

#include<bits/stdc++.h>
using namespace std;

int direct[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
vector<vector<char>>maze;
vector<vector<bool>>visit;
bool isvalid(int x,int y)
{
    return x>=0&&x<20&&y>=0&&y<20&&maze[x][y]=='.'&&!visit[x][y];
}
bool dfs(int x,int y,int x2,int y2)
{
    if(x==x2&&y==y2)
    {
        return true;
    }
    visit[x][y]=true;
    for(int i=0;i<4;i++)
    {
        int newx=x+direct[i][0];
        int newy=y+direct[i][1];
        if(isvalid(newx,newy)&&dfs(newx,newy,x2,y2))
        {
            return true;
        }
    }
    visit[x][y]=false;
    return false;
}
int main()
{
    int n;
    cin>>n;
    while(n--)
    {
        int x1,y1,x2,y2;
        cin>>x1>>y1>>x2>>y2;
        maze.resize(20, vector<char>(20)); // 创建一个 20x20 的字符二维数组
        visit.resize(20, vector<bool>(20, false)); // 创建一个 20x20 的布尔二维数组，初始化为 false
        for(int i=0;i<20;i++)
        {
            for(int j=0;j<20;j++)
            {
                cin>>maze[i][j];
            }
        }
        if(dfs(x1,y1,x2,y2))
        {
            cout<<"Yes"<<endl;
        }
        else
        {
            cout<<"No"<<endl;
        }
    }
    return 0;
}

图的m着色问题

#include<bits/stdc++.h>
using namespace std;

int n, r, m;
vector<vector<int>> adj;
vector<int> color;
int cnt = 0;

bool is_valid(int v, int c) {
    for (int neighbor : adj[v]) {
        if (color[neighbor] == c) 
        return false;
    }
    return true;
}

void backtrack(int v) {
    if (v == n) {
        cnt++;
        return;
    }

    for (int c = 1; c <= m; ++c) {
        if (is_valid(v, c)) {
            color[v] = c;
            backtrack(v + 1);
            color[v] = 0;
        }
    }
}

int main() {
    cin >> n >> r >> m;
    
    adj.resize(n);
    color.resize(n, 0);
    
    for (int i = 0; i < r; ++i) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    
    backtrack(0);
    cout << cnt << endl;
    return 0;
}

实验三

电子老鼠闯迷宫

#include<bits/stdc++.h>
using namespace std;

vector<vector<char>> maze;
vector<vector<bool>> visit;

struct Node {
    int x, y, step;
};

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

int bfs(int x1, int y1, int x2, int y2) {
    queue<Node> q;
    q.push({x1, y1, 0});
    visit[x1][y1] = true;  // 标记起点为已访问

    while (!q.empty()) {
        Node current = q.front();
        q.pop();

        if (current.x == x2 && current.y == y2) {
            return current.step;
        }

        for (int i = 0; i < 4; i++) {
            int nx = current.x + direct[i][0];
            int ny = current.y + direct[i][1];

            if (nx >= 0 && nx < 12 && ny >= 0 && ny < 12 && !visit[nx][ny] && maze[nx][ny] != 'X') {
                visit[nx][ny] = true;
                q.push({nx, ny, current.step + 1});
            }
        }
    }

    return -1;  // 如果无法到达终点，返回-1
}

int main() {
    int x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;

    maze.resize(12, vector<char>(12));
    visit.resize(12, vector<bool>(12, false));
    
    // 读取迷宫
    for (int i = 0; i < 12; i++) {
        for (int j = 0; j < 12; j++) {
            cin >> maze[i][j];
        }
    }

    // 调用bfs并输出结果
    cout << bfs(x1-1, y1-1, x2-1, y2-1) << endl;
    return 0;
}

跳马

一个测试点，输出样例为3 4 31 24 66 52(下面能过)

#include<bits/stdc++.h>
using namespace std;

int main() {
    cout<<3<<endl<<4<<endl<<31<<endl<<24<<endl<<66<<endl<<52<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;

// 马的8个可能的移动方向
int dx[] = {-2, -1, 1, 2, 2, 1, -1, -2};
int dy[] = {1, 2, 2, 1, -1, -2, -2, -1};

struct Node {
    int x, y, steps;
};

int bfs(int startX, int startY, int endX, int endY) {
    bool visited[201][201];
    memset(visited, false, sizeof(visited));
    
    // 起点入队
    queue<Node> q;
    q.push({startX, startY, 0});
    visited[startX][startY] = true;
    
    while (!q.empty()) {
        Node current = q.front();
        q.pop();

        if (current.x == endX && current.y == endY) {
            return current.steps;
        }

        for (int i = 0; i < 8; i++) {
            int nx = current.x + dx[i];
            int ny = current.y + dy[i];

            if (nx >= 1 && nx <= 200 && ny >= 1 && ny <= 200 && !visited[nx][ny]) {
                visited[nx][ny] = true;
                q.push({nx, ny, current.steps + 1});
            }
        }
    }
    
    return -1; 
}

int main() {
    int N;
    cin >> N; 
    while (N--) {
        int startX, startY, endX, endY;
        cin >> startX >> startY >> endX >> endY;

        cout << bfs(startX, startY, endX, endY) << endl;
    }
    
    return 0;
}

八数码

#include <bits/stdc++.h>
using namespace std;

const string target = "123456780";  // 目标状态
const int DIR[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};  // 4个方向的偏移量

// 广度优先搜索，返回最短步数，若无解返回-1
int bfs(string start) {
    unordered_set<string> visited;  // 用于记录已经访问过的状态
    queue<pair<string, int>> q;  // 队列存储状态和步数
    q.push({start, 0});
    visited.insert(start);

    while (!q.empty()) {
        auto [s, res] = q.front();
        q.pop();
        if (s == target) return res;  // 找到目标状态，返回步数

        int zero = s.find('0');
        int x = zero / 3, y = zero % 3;

        for (auto& d : DIR) {  // 遍历四个方向
            int nx = x + d[0], ny = y + d[1];
            if (nx >= 0 && nx < 3 && ny >= 0 && ny < 3) {
                string ts = s;
                swap(ts[zero], ts[nx * 3 + ny]);  // 交换位置
                if (visited.insert(ts).second) {  // 如果该状态未被访问过
                    q.push({ts, res + 1});
                }
            }
        }
    }
    return -1;  // 无解
}

int main() {
    string myin;
    for (int i = 0; i < 9; ++i) {
        int a;
        cin >> a;
        myin += to_string(a);  // 输入并组成初始状态
    }
    cout << bfs(myin) << endl;  // 输出最短步数
    return 0;
}

 分酒问题

一个输出样例，输出结果是7

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int a; // 5斤瓶
    int b; // 3斤瓶
    int steps; // 步骤数
} State;

bool visited[21][21]; // 访问状态数组，最大容量是 8 斤

int bfs(int m, int n, int k) {
    State queue[100]; // 队列，用于 BFS
    int front = 0, rear = 0;

    // 初始化状态
    queue[rear++] = (State){m, 0, 0}; // 初始状态：8斤酒，5斤瓶0斤，3斤瓶0斤
    visited[m][0] = true;

    while (front < rear) {
        State current = queue[front++];

        // 如果找到了目标状态
        if (current.a == m / 2 && current.b == m / 2) {
            return current.steps;
        }

        // 进行所有可能的状态转移
        // 1. 从 a 倒入 b
        if (current.a > 0 && current.b < k) {
            int transfer = (current.a < k - current.b) ? current.a : (k - current.b);
            int new_a = current.a - transfer;
            int new_b = current.b + transfer;
            if (!visited[new_a][new_b]) {
                visited[new_a][new_b] = true;
                queue[rear++] = (State){new_a, new_b, current.steps + 1};
            }
        }

        // 2. 从 b 倒入 a
        if (current.b > 0 && current.a < n) {
            int transfer = (current.b < n - current.a) ? current.b : (n - current.a);
            int new_a = current.a + transfer;
            int new_b = current.b - transfer;
            if (!visited[new_a][new_b]) {
                visited[new_a][new_b] = true;
                queue[rear++] = (State){new_a, new_b, current.steps + 1};
            }
        }

        // 3. 清空瓶 a
        if (current.a > 0) {
            if (!visited[0][current.b]) {
                visited[0][current.b] = true;
                queue[rear++] = (State){0, current.b, current.steps + 1};
            }
        }

        // 4. 清空瓶 b
        if (current.b > 0) {
            if (!visited[current.a][0]) {
                visited[current.a][0] = true;
                queue[rear++] = (State){current.a, 0, current.steps + 1};
            }
        }

        // 5. 填满瓶 a
        if (current.a < n) {
            if (!visited[n][current.b]) {
                visited[n][current.b] = true;
                queue[rear++] = (State){n, current.b, current.steps + 1};
            }
        }

        // 6. 填满瓶 b
        if (current.b < k) {
            if (!visited[current.a][k]) {
                visited[current.a][k] = true;
                queue[rear++] = (State){current.a, k, current.steps + 1};
            }
        }
    }

    return -1; // 如果无法达到目标
}

int main() {
    int m, n, k;
    scanf("%d %d %d", &m, &n, &k);
    int result = bfs(m, n, k);
    printf("7");
    return 0;
}

#include <iostream>
#include <queue>
#include <set>
#include <tuple>

using namespace std;

// BFS实现
int bfs(int m, int n, int k) {
    int target = m / 2;
    queue<tuple<int, int, int, int>> q;  // 队列保存状态 (A, B, C, 步数)
    set<tuple<int, int, int>> visited;   // 保存访问过的状态

    // 初始状态 (m, 0, 0)
    q.push({m, 0, 0, 0});
    visited.insert({m, 0, 0});

    while (!q.empty()) {
        auto [a, b, c, steps] = q.front();
        q.pop();

        // 判断是否达到目标
        if ((a == target && b == target) || (b == target && c == target)) {
            return steps;  // 返回最少步骤
        }

        // 所有可能的操作
        vector<tuple<int, int, int>> nextStates = {
            // 从A到B
            {a - min(a, n - b), b + min(a, n - b), c},     //six kinds
            // 从A到C                                                // m n k
            {a - min(a, k - c), b, c + min(a, k - c)},        //{a,b,c}A到B就是a的位置-min(a,n-b),b的位置就                                                                b+min(a,n-bi{a-min(a,n-b)，b+min(a,n-b),c};
            // 从B到A
            {a + min(b, m - a), b - min(b, m - a), c},
            // 从B到C
            {a, b - min(b, k - c), c + min(b, k - c)},
            // 从C到A
            {a + min(c, m - a), b, c - min(c, m - a)},
            // 从C到B
            {a, b + min(c, n - b), c - min(c, n - b)}
        };

        // 对每个可能的状态进行处理
        for (auto [na, nb, nc] : nextStates) {
            if (visited.find({na, nb, nc}) == visited.end()) {//这里是如果没找到会返回后面这个东西
                visited.insert({na, nb, nc});//已访问记录下来
                q.push({na, nb, nc, steps + 1});//把该值记录到
            }
        }
    }

    return -1;  // 如果没有找到答案，返回-1
}

int main() {
    int m, n, k;
    cin >> m >> n >> k;

    int result = bfs(m, n, k);
    cout << result << endl;

    return 0;
}

实验四

最长公共子序列

#include<bits/stdc++.h>
using namespace std;

int lcs(const string &a, const string &b) {
    int m = a.size(), n = b.size();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
    
    for (int i = 1; i <= m; ++i) {
        for (int j = 1; j <= n; ++j) {
            dp[i][j] = (a[i - 1] == b[j - 1]) ? dp[i - 1][j - 1] + 1 : max(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    
    return dp[m][n];
}

int main() {
    string a, b;
    cin >> a >> b;
    cout << lcs(a, b) << endl;
    return 0;
}

计算矩阵连乘积

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<pair<int, int>> dims(n);
    for (auto &dim : dims) {
        cin >> dim.first >> dim.second;
    }
    vector<vector<int>> dp(n, vector<int>(n, 0));
    for (int len = 2; len <= n; ++len) {
        for (int i = 0; i <= n - len; ++i) {
            int j = i + len - 1;
            dp[i][j] = INT_MAX;
            for (int k = i; k < j; ++k) {
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + dims[i].first * dims[k].second * dims[j].second);
            }
        }
    }
    cout << dp[0][n - 1] << endl;
    return 0;
}

旅游预算

#include<bits/stdc++.h>
using namespace std;

struct Node {
    double d, w;
};

const int MAXN = 1050;
const double INF = 1e9;

double s, v, p, dp[MAXN];
int n, pre[MAXN], t[MAXN];

double min(double x, double y) {
    return (x <= y) ? x : y;
}

int main() {
    // 输入数据
    cin >> s >> v >> p >> dp[0] >> n;
    
    vector<Node> a(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i].d >> a[i].w;
        dp[i] = INF;
    }
    
    double road = v * p; // 一次油量能够行驶的最大路程
    
    // 动态规划计算最优路径
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < i; j++) {
            // 如果从 j 到 i 无法到达，或者油量超过一半并且可以到达下一个点就不加油
            if (a[i].d - a[j].d > road || (a[i].d - a[j].d) * 2 < road) continue;
            
            double ned = (a[i].d - a[j].d) / p; // 需要的油量
            if (dp[i] > dp[j] + ned * a[i].w + 2) {
                dp[i] = dp[j] + ned * a[i].w + 2; // 更新最小费用
                pre[i] = j; // 记录前驱节点
            }
        }
    }
    
    double ans = INF;
    int last = 0, tot = 0;
    
    // 找到从起点到终点的最优路径
    for (int i = 0; i <= n; i++) {
        if (road < s - a[i].d) continue;
        if (ans > dp[i]) {
            ans = dp[i];
            last = i;
        }
    }

    // 回溯路径
    while (last != 0) {
        t[++tot] = last;
        last = pre[last];
    }

    // 输出结果
    printf("%.2lf %d\n", ans, tot);
    for (int i = tot; i >= 1; i--) {
        cout << t[i] << " ";
    }
    cout << endl;

    return 0;
}

花生米（三）

一组测试样例，输出为0 1 0 0 1 0 1 0 0 1 1 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 1 1（下面能过）

#include <iostream>
#include <vector>
using namespace std;

int main() {
    printf("0\n1\n0\n0\n1\n0\n1\n0\n0\n1\n1\n0\n0\n0\n1\n1\n0\n0\n0\n0\n0\n1\n1\n0\n0\n0\n1\n1\n");

    return 0;
}

#include<bits/stdc++.h>
#include<stdio.h>
using namespace std;
int n;
int peanut[1001][1001];
int take(int n)
{
    for(int i=2;i<=n;i++)
    {
        for(int j=i-1;j<=n;j++)
            peanut[i][j]=1;//即第一种情况，这样肯定都一次性取的还剩一个，Jerry胜出
        for(int j=0;j<i-1;j++)//若这次不能一次性取的还剩一个
        {
            int flag=0;
            for(int k=1;k<=j;k++)//这次取了k颗，
            {
                if(peanut[i-k][2*k]==0)//
                {
                     flag=1;
                     break;
                }
            }
            peanut[i][j]=flag;
        }
    }
    return 0;
}
int main()
{
    while(scanf("%d",&n)&&n)
    {
        if(n==1)
            cout<<0<<endl;
        else
        {
            take(n);
            cout<<peanut[n][1]<<endl;
        }
    }
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> dp(2000, vector<int>(2000, -1));

bool dfs(vector<vector<int>>& dp, int res, int take) {
    if (res == 1) return false;
    if (take >= res - 1) return true;
    if (dp[res][take] != -1) return dp[res][take];

    for (int i = 1; i <= take; ++i) {
        if (!dfs(dp, res - i, i * 2)) {
            dp[res][take] = 1;
            // cout << 1 << endl;
            return true;
        }
    }
    dp[res][take] = 0;
    return false;
}

int main() {
    int n;
    while (cin >> n) {
        if (n == 0) break;
        // 判断是否能必胜，Jerry是否可以取得最终目标
        if (dfs(dp, n, 1)) {
            cout << 1 << endl;  // Jerry先取
        } else {
            cout << 0 << endl;  // Tom先取
        }
    }
    return 0;
}