数据结构实验报告

Miracle24

于 2020-12-21 22:26:33 发布

阅读量1.4k

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ 数据结构文章标签： c++ 数据结构

本文链接：https://blog.youkuaiyun.com/JK_spc/article/details/111501309

这篇数据结构实验报告涵盖了多个经典问题的算法实现，包括背包问题、农夫过河、八皇后问题、约瑟夫环及迷宫问题。通过深度优先搜索和二叉树等数据结构，实现了各种问题的解决方案，并展示了运行结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

数据结构实验报告

专业班级：计算机**
姓名：***
学号：**********
联系电话：**********
电子邮箱：Miracle20001110@gmail.com
时间：2020年12月17日

实验一：背包问题求解

问题描述：

假设有一个能装入总体积为T的背包和n件体积分别为w1,w2,…wn的物品，能否从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+wm=T，要求找出所有满足上述条件的解。

算法思路：

采用深搜实现枚举每个物品选择的状态（选/未选），到最底层判定体积之和是否等于T。
用体积过大或过小经行剪枝优化。

代码实现：

#include <cstdio>
#include <algorithm>

const int MAXN = 1e3;
const int MAXV = 1e5;

int n, V, w[MAXN+5], v[MAXN+5];

/**
假设有一个能装入总体积为T的背包和n件体积分别为w1,w2,…wn的物品，能否
从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+wm=T，要求找出所有满足上述条件的解。
      例如：当T=10，各件物品的体积{1,8,4,3,5,2}时，可找到下列4组解：
    	(1,4,3,2)
     	(1,4,5)
     	(8,2)
     	(3,5,2)。

6 10
1 8 4 3 5 2

**/
int rsum[MAXN+5];
int pth[MAXN+5], pcnt;
void dp(int u, int v){
   
   /// O(2^n)
    if(v == V){
   
   
        putchar('(');
        for(int i = 1; i < pcnt; ++ i)
            printf("%d,",pth[i]);
        printf("%d)\n",pth[pcnt]);
        return;
    }
    if(u>n || v>V || v+rsum[u]<V) return;
    dp(u+1, v);
    pth[++pcnt] = w[u];
    dp(u+1, v+w[u]);
    pth[pcnt--] = 0;
    return;
}

/**
进一步考虑：如果每件物品都有体积和价值，背包又有大小限制，
求解背包中存放物品总价值最大的问题解---最优解或近似最优解。
**/
int f[MAXV];
int dp_max_value(){
   
   /// O(n*V)
    for(int i = 1; i <= n; ++ i)
        for(int j = V; j >= w[i]; -- j)
            f[j] = std::max(f[j], f[j-w[i]]+v[i]);
    return f[V];
}

int main(){
   
   
    freopen("task1.in", "r", stdin);
    freopen("task1.out", "w", stdout);

    scanf("%d%d",&n,&V);
    for(int i = 1; i <= n; ++ i)
        scanf("%d",&w[i]);
    for(int i = n; i >= 1; -- i)
        rsum[i] = rsum[i+1]+w[i];
    dp(1, 0);
    return 0;
}

运行结果：

(3,5,2)
(8,2)
(1,4,5)
(1,4,3,2)

实验二：农夫过河问题的求解

问题描述：

一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸。他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜，否则狼会吃羊，羊会吃白菜，所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不吃白菜。请求出农夫将所有的东西运过河的方案。

算法思路：

用二进制数的每一位的“0/1”表示在“南/北”岸，用广搜实现初始状态（0000）到目标状态（1111）路径的搜索。

代码实现：

#include <cstdio>
#include <queue>

const int MAXS = 1<<4;
const char Names[4][10] = {
   
   "cabbage","sheep","wolf","farmer"};

bool vis[MAXS+5];
int pth[MAXS+5], pcnt;

///farmer,wolf,sheep,cabbage
bool flg[1<<4];

/// Q for bfs
std::queue<int> Q;

int Print(int u){
   
   
    if(!u) return 1;
    int s = Print(pth[u]);
    printf("step%d:\n",s);
    printf("    north: ");
    for(int i = 0; i < 4; ++ i)
        if(u&(1<<i)) printf("%s ",Names[i]);
    putchar(10);
    printf("    south: ");
    for(int i = 0; i < 4; ++ i)
        if(!(u&(1<<i))) printf("%s ",Names[i]);
    putchar(10);
    return s+1;
}

int main(){
   
   
    freopen("task2.out", "w", stdout);

    flg[0b0111] = flg[0b0110] = flg[0b0011] = flg[0b1000] = flg[0b1001] = flg[0b1100] = 1;

    int u = 0b0000, tu;
    Q.push(u);
    while(!Q.empty()){
   
   
        u = Q.front(), Q.pop();
        u ^= 1<<3;
        if(!flg[u] && !vis[u]){
   
   
            vis[u] = 1;
            pth[u] = u^(1<<3);
            Q.push(u);
        }
        for(int i = 0; i < 3; ++ i)
            if((u&(1<<3))^(u&(1<<i))){
   
   
                tu = u^(1<<i);
                if(!flg[tu] && !vis[tu]){
   
   
                    vis[tu] = 1;
                    pth[tu] = u^(1<<3);
                    Q.push(tu);
                }
            }
    }
    Print(0b1111);
    return 0;
}

运行结果：

step1:
    north: sheep farmer 
    south: cabbage wolf 
step2:
    north: sheep 
    south: cabbage wolf farmer 
step3:
    north: cabbage sheep farmer 
    south: wolf 
step4:
    north: cabbage 
    south: sheep wolf farmer 
step5:
    north: cabbage wolf farmer 
    south: sheep 
step6:
    north: cabbage wolf 
    south: sheep farmer 
step7:
    north: cabbage sheep wolf farmer 
    south:

实验四：八皇后问题

问题描述：

设在初始状态下在国际象棋的棋盘上没有任何棋子（这里的棋子指皇后棋子）。然后顺序在第1行，第2行……第8行上布放棋子。在每一行中共有8个可选择的位置，但在任一时刻棋盘的合法布局都必须满足3个限制条件（1）任意两个棋子不得放在同一行（2）任意两个棋子不得放在同一列上（3）任意棋子不得放在同一正斜线和反斜线上。

算法思路：

通过深搜实现枚举状态。
采用二进制优化状态的表述、判定与枚举。

代码实现：

#include <cstdio>

bool tag;
int row, lim=(1<<8)-1, pth[10];

void dfs(int d, int ld, int rd){
   
   
    if(tag) return;
    int pos = ~(row|ld|rd);
    rd &= lim;
    pos &= lim;
    while(pos && !tag){
   
   
        int p = pos&(~pos+1);
        p &= lim;
        pos -= p;
        row |= p;
        if(row != lim){
   
   
            pth[d] = p;
            dfs(d+1, (ld|p)<<1, (rd|p)>>1);
            if(!tag) pth[d] = 0;
        }else pth[d] = p, tag = 1;
        row = row&~p;
    }
    return;
}


int main(){
   
   
    freopen("task4.out", "w", stdout);

    dfs(1, 0, 0);
    for(int i = 1; i <= 8; ++ i){
   
   
        for(int j = 0; j < 8; ++ j)
            putchar((pth[i]&(1<<j)) ? '#':'*');
        putchar(10);
    }
    return 0