【第十一周】项目4 - 利用遍历思想求解图问题

最新推荐文章于 2021-05-07 21:42:04 发布
最新推荐文章于 2021-05-07 21:42:04 发布
阅读量157 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljj19971222/article/details/78673427
版权 
*Copyright (c)2017,烟台大学计算机与控制工程学院                     
*All rights reserved.                     
*文件名称：                     
*作    者：李佳骏                    
*完成日期：2017年11月30日                     
*版 本 号：v1.0                     
*问题描述：数据结构实践——利用遍历思想求解图问题             
                     
*输入描述： 无                
*程序输出： <span style="color:#33cc00;">  </span>
问题及描述： 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 
　　（1）设计一个算法，判断顶点u到v是否有简单路径 
　　（2）设计一个算法输出图G中从顶点u到v的一条简单路径（设计测试图时，保证图G中从顶点u到v至少有一条简单路径）。 
　　（3）输出从顶点u到v的所有简单路径。 
　　（4）输出图G中从顶点u到v的长度为s的所有简单路径。 
　　（5）求图中通过某顶点k的所有简单回路（若存在） 
　　（6）求不带权连通图G中从顶点u到顶点v的一条最短路径。 

　　（7）求不带权连通图G中，距离顶点v最远的顶点k 


（1）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void ExistPath(ALGraph *G,int u,int v, bool &has)
{
    int w;
    ArcNode *p;
    visited[u]=1;
    if(u==v)
    {
        has=true;
        return;
    }
    p=G->adjlist[u].firstarc;
    while (p!=NULL)
    {
        w=p->adjvex;
        if (visited[w]==0)
            ExistPath(G,w,v,has);
        p=p->nextarc;
    }
}

void HasPath(ALGraph *G,int u,int v)
{
    int i;
    bool flag = false;
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    ExistPath(G,u,v,flag);
    printf(" 从 %d 到 %d ", u, v);
    if(flag)
        printf("有简单路径\n");
    else
        printf("无简单路径\n");
}

int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {0,0,0,0,0},
        {0,0,1,0,0},
        {0,0,0,1,1},
        {0,0,0,0,0},
        {1,0,0,1,0},
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    HasPath(G, 1, 0);
    HasPath(G, 4, 1);
    return 0;
}

（2）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void FindAPath(ALGraph *G,int u,int v,int path[],int d)
{
    //d表示path中的路径长度，初始为-1
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;
    path[d]=u;  //路径长度d增1，顶点u加入到路径中
    if (u==v)   //找到一条路径后输出并返回
    {
        printf("一条简单路径为:");
        for (i=0; i<=d; i++)
            printf("%d ",path[i]);
        printf("\n");
        return;         //找到一条路径后返回
    }
    p=G->adjlist[u].firstarc;  //p指向顶点u的第一个相邻点
    while (p!=NULL)
    {
        w=p->adjvex;    //相邻点的编号为w
        if (visited[w]==0)
            FindAPath(G,w,v,path,d);
        p=p->nextarc;   //p指向顶点u的下一个相邻点
    }
}

void APath(ALGraph *G,int u,int v)
{
    int i;
    int path[MAXV];
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    FindAPath(G,u,v,path,-1);  //d初值为-1，调用时d++，即变成了0
}

int main()
{

    ALGraph *G;
    int A[5][5]=
    {
        {0,0,0,0,0},
        {0,0,1,0,0},
        {0,0,0,1,1},
        {0,0,0,0,0},
        {1,0,0,1,0},
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    APath(G, 1, 0);
    APath(G, 4, 1);
    return 0;
}

（3）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void FindPaths(ALGraph *G,int u,int v,int path[],int d)
//d是到当前为止已走过的路径长度，调用时初值为-1
{
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;            //路径长度增1
    path[d]=u;              //将当前顶点添加到路径中
    if (u==v && d>1)            //输出一条路径
    {
        printf("  ");
        for (i=0; i<=d; i++)
            printf("%d ",path[i]);
        printf("\n");
    }
    p=G->adjlist[u].firstarc; //p指向u的第一条边
    while(p!=NULL)
    {
        w=p->adjvex;     //w为u的邻接顶点
        if (visited[w]==0)      //若顶点未标记访问，则递归访问之
            FindPaths(G,w,v,path,d);
        p=p->nextarc; //找u的下一个邻接顶点
    }
    visited[u]=0;   //恢复环境
}


void DispPaths(ALGraph *G,int u,int v)
{
    int i;
    int path[MAXV];
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    printf("从%d到%d的所有路径:\n",u,v);
    FindPaths(G,u,v,path,-1);
    printf("\n");
}

int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {0,1,0,1,0},
        {1,0,1,0,0},
        {0,1,0,1,1},
        {1,0,1,0,1},
        {0,0,1,1,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    DispPaths(G, 1, 4);
    return 0;
}

（4）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void SomePaths(ALGraph *G,int u,int v,int s, int path[],int d)
//d是到当前为止已走过的路径长度，调用时初值为-1
{
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;            //路径长度增1
    path[d]=u;              //将当前顶点添加到路径中
    if (u==v && d==s)           //输出一条路径
    {
        printf("  ");
        for (i=0; i<=d; i++)
            printf("%d ",path[i]);
        printf("\n");
    }
    p=G->adjlist[u].firstarc; //p指向u的第一条边
    while(p!=NULL)
    {
        w=p->adjvex;     //w为u的邻接顶点
        if (visited[w]==0)      //若顶点未标记访问，则递归访问之
            SomePaths(G,w,v,s,path,d);
        p=p->nextarc; //找u的下一个邻接顶点
    }
    visited[u]=0;   //恢复环境
}

void DispSomePaths(ALGraph *G,int u,int v, int s)
{
    int i;
    int path[MAXV];
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    printf("从%d到%d长为%d的路径:\n",u,v,s);
    SomePaths(G,u,v,s,path,-1);
    printf("\n");
}

int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {0,1,0,1,0},
        {1,0,1,0,0},
        {0,1,0,1,1},
        {1,0,1,0,1},
        {0,0,1,1,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    DispSomePaths(G, 1, 4, 3);
    return 0;
}

（5）

#include <stdio.h>
#include <malloc.h>
#include "op.h"
int visited[MAXV];       //全局变量
void DFSPath(ALGraph *G,int u,int v,int path[],int d)
//d是到当前为止已走过的路径长度，调用时初值为-1
{
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;
    path[d]=u;
    p=G->adjlist[u].firstarc;   //p指向顶点u的第一条边
    while (p!=NULL)
    {
        w=p->adjvex;            //w为顶点u的相邻点
        if (w==v && d>0)        //找到一个回路，输出之
        {
            printf("  ");
            for (i=0; i<=d; i++)
                printf("%d ",path[i]);
            printf("%d \n",v);
        }
        if (visited[w]==0)          //w未访问，则递归访问之
            DFSPath(G,w,v,path,d);
        p=p->nextarc;       //找u的下一个邻接顶点
    }
    visited[u]=0;           //恢复环境：使该顶点可重新使用
}

void FindCyclePath(ALGraph *G,int k)
//输出经过顶点k的所有回路
{
    int path[MAXV],i;
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    printf("经过顶点%d的所有回路\n",k);
    DFSPath(G,k,k,path,-1);
    printf("\n");
}

int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {0,1,1,0,0},
        {0,0,1,0,0},
        {0,0,0,1,1},
        {0,0,0,0,1},
        {1,0,0,0,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    FindCyclePath(G, 0);
    return 0;
}

（6）

#include <stdio.h>
#include <malloc.h>
#include "op.h"

typedef struct
{
    int data;                   //顶点编号
    int parent;                 //前一个顶点的位置
} QUERE;                        //非环形队列类型

void ShortPath(ALGraph *G,int u,int v)
{
    //输出从顶点u到顶点v的最短逆路径
    ArcNode *p;
    int w,i;
    QUERE qu[MAXV];             //非环形队列
    int front=-1,rear=-1;       //队列的头、尾指针
    int visited[MAXV];
    for (i=0; i<G->n; i++)      //访问标记置初值0
        visited[i]=0;
    rear++;                     //顶点u进队
    qu[rear].data=u;
    qu[rear].parent=-1;
    visited[u]=1;
    while (front!=rear)         //队不空循环
    {
        front++;                //出队顶点w
        w=qu[front].data;
        if (w==v)               //找到v时输出路径之逆并退出
        {
            i=front;            //通过队列输出逆路径
            while (qu[i].parent!=-1)
            {
                printf("%2d ",qu[i].data);
                i=qu[i].parent;
            }
            printf("%2d\n",qu[i].data);
            break;
        }
        p=G->adjlist[w].firstarc;   //找w的第一个邻接点
        while (p!=NULL)
        {
            if (visited[p->adjvex]==0)
            {
                visited[p->adjvex]=1;
                rear++;             //将w的未访问过的邻接点进队
                qu[rear].data=p->adjvex;
                qu[rear].parent=front;
            }
            p=p->nextarc;           //找w的下一个邻接点
        }
    }
}

int main()
{
    ALGraph *G;
    int A[9][9]=
    {
        {0,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,0,0,0,0},
        {0,0,0,0,1,1,0,0,0},
        {0,0,0,0,0,0,1,0,0},
        {0,0,0,0,0,1,1,0,0},
        {0,0,0,0,0,0,0,1,0},
        {0,0,0,0,0,0,0,1,1},
        {0,0,0,0,0,0,0,0,1},
        {0,0,0,0,0,0,0,0,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 9, G);
    ShortPath(G,0,7);
    return 0;
}

（7）

#include <stdio.h>
#include <malloc.h>
#include "op.h"

int Maxdist(ALGraph *G,int v)
{
    ArcNode *p;
    int i,j,k;
    int Qu[MAXV];               //环形队列
    int visited[MAXV];              //访问标记数组
    int front=0,rear=0;             //队列的头、尾指针
    for (i=0; i<G->n; i++)          //初始化访问标志数组
        visited[i]=0;
    rear++;
    Qu[rear]=v;                 //顶点v进队
    visited[v]=1;               //标记v已访问
    while (rear!=front)
    {
        front=(front+1)%MAXV;
        k=Qu[front];                //顶点k出队
        p=G->adjlist[k].firstarc;       //找第一个邻接点
        while (p!=NULL)             //所有未访问过的相邻点进队
        {
            j=p->adjvex;            //邻接点为顶点j
            if (visited[j]==0)          //若j未访问过
            {
                visited[j]=1;
                rear=(rear+1)%MAXV;
                Qu[rear]=j; //进队
            }
            p=p->nextarc;           //找下一个邻接点
        }
    }
    return k;
}

int main()
{
    ALGraph *G;
    int A[9][9]=
    {
        {0,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,0,0,0,0},
        {0,0,0,0,1,1,0,0,0},
        {0,0,0,0,0,0,1,0,0},
        {0,0,0,0,0,1,1,0,0},
        {0,0,0,0,0,0,0,1,0},
        {0,0,0,0,0,0,0,1,1},
        {0,0,0,0,0,0,0,0,1},
        {0,0,0,0,0,0,0,0,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 9, G);
    printf("离顶点0最远的顶点:%d",Maxdist(G,0));
    return 0;
}

VI_YeQiu
关注
第十二周项目4-利用遍历思想求解图问题（1-深度优先遍历）
cr496352127的博客
11-18 467
问题： /* copyright （t） 2016，烟台大学计算机学院 *All rights reserved. *文件名称：1.cpp *作者：常锐 *完成日期：2016年11月18日 *版本号：v1.0 *问题描述：假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 　　（1）设计一个算法，判断顶
【微信小程序】小程序读取本地数据
热门推荐
走在冷风中的博客
04-26 3万+
一般情况下，小程序的utils这个文件夹下，我们可以把本地的数据写进去，封装成.js文件，提供对外暴露的接口，然后读取本地数据。如果涉及到一些针对这些数据的处理方法，也可以把方法写好，封装到.js文件里面，然后需要时调用。 module.exports = { mtData: mtData, searchmtdata: searchmtdata, usedraw: use
cannot convert ‘......‘ to ‘void*‘ for argument ‘1‘ to ‘void free(void*)‘
weixin_43638873的博客
05-07 3456
出现这种情况的可能原因是你所要free掉的这个压根就不是一个指针类型的数据
第十一周 项目4 - 利用遍历思想求解图问题
renyuansun的博客
12-28 178
/* Copyright (c)2017,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：第十一周项目4 - 利用遍历思想求解图问题.cpp 作 者：孙仁圆 完成日期：2017年12月27日 版 本 号：v1.0 问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题
第11周项目4-利用遍历思想求解图问题
计算机科学与技术
12-14 180
/*  *Copyright(c)2017,烟台大学计算机学院  *All right reserved.  *文件名：sk.cpp btree.h btree.cpp  *作者：盛凯  *完成日期：2017年12月14日  *版本号：v1.0  *  *问题描述:利用遍历思想求解图问题 *输入描述：无  *程序输出：见运行结果 sk.cpp:
第11周项目4 - 利用遍历思想求解图问题（1）
QianMo的博客
11-09 137
问题及代码： /* * Copyright (c)2017,烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称：main.cpp * 作 者：王效杰 * 完成日期：2017年11月9日 * 版 本 号：v1.0 * 问题描述：假设图G采用邻接表存储，设计一个算法，判断顶点u到v是否有简单路径。 */ #include #include #inclu
第十二周 项目4 -利用遍历思想求解图问题
zwj201558506220的博客
11-12 533
问题描述及代码： /*  Copyright (c)2015,烟台大学计算机与控制工程学院  All rights reserved.  文件名称：利用遍历思想求解图问题.cpp  作    者：张雯婧 完成日期：2016年11月12日  版 本 号：v1.0   问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处
第十二周项目4 - 利用遍历思想求解图问题6
滕健的博客
11-17 167
/* Copyright (c)2016,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：第十二周项目4 - 利用遍历思想求解图问题6.cpp 作 者：滕健 完成日期：2016年11月17日 问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。
第十二周项目4 - 利用遍历思想求解图问题7
滕健的博客
11-17 219
/* Copyright (c)2016,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：第十二周项目4 - 利用遍历思想求解图问题7.cpp 作 者：滕健 完成日期：2016年11月17日 问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。
第十二周项目4-利用遍历思想求解图问题
甘乐2333的博客
11-20 180
问题及代码： /* 烟台大学计算机与控制工程学院 作 者：房斐 完成日期：2016年11月20日 问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 　　 （1）设计一个算法，判断顶点u到v是否有简单路径 　　 （2）设计一个算法输出图G中从顶点u到v的...
第11周项目4- 利用遍历思想求解图问题(3)
Rachel_71的博客
11-14 245
问题及代码： /* * Copyright(c) 2017,烟台大学计算机学院 * All rights reserved. * 文件名称:cpp1. * 作 者:薛瑞琪 * 完成日期:2017 年 11 月 14 日 * 版 本 号:v1.0 * * 问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观
第11周项目4- 利用遍历思想求解图问题(2)
Rachel_71的博客
11-14 279
问题及代码： /* * Copyright(c) 2017,烟台大学计算机学院 * All rights reserved. * 文件名称:cpp1. * 作 者:薛瑞琪 * 完成日期:2017 年 11 月 14 日 * 版 本 号:v1.0 * * 问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观
第十二周 项目4-利用遍历思想求解图问题（1.2.3）
YY1562cjy的博客
11-17 294
问题及代码： /* * Copyright (c)2016,烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称：项目4.cpp * 作 者：车佳颖 * 完成日期：2016年11月17日 * 版 本 号：v1.0 *问题描述：假设图G采用邻接表存储，分别设计实现以
第十二周 项目4-利用遍历思想求解图问题（1)(2)
zcqdlixin的博客
11-24 269
/* *Copyright （c）2016，烟台大学计算机学院 *All rights reserved. *文件名称：传写.cpp *作者：李欣 *完成日期：2016年11月24日 *版本号：v1.0 * */         1、是否有简单路径?         问题：假设图G采用邻接表存储，设计一个算法，判断顶点u到v是否有简单路径。   main.
第十二周 项目4-利用遍历思想求解图问题（2）
zj2558562310的博客
11-23 259
/*   *Copyright(c) 2015, 烟台大学计算机学院   *All rights reserved.   *文件名称：利用遍历思想求解图问题（2）.cpp   *作    者：周洁   *完成日期：2015年 11月23日   *版 本 号：   *   *问题描述：假设图G采用邻接表存储，设计一个算法输出图G中从顶点u到v的一条简单路径（假设图G中从顶点u到v
基于yolov3结合卡尔曼滤波匈牙利算法虚拟线圈的车流量检测python源码+项目说明.zip
09-21
本项目专注于视频基的车辆跟踪与流量统计，依托深度学习技术，实时追踪路面车辆动态并精准统计各车道车流量。该项目通过以下核心步骤高效处理输入视频数据： 高精度目标检测：采用YOLOv3模型，凭借其卓越的实时性与准确性，快速识别视频中的车辆目标，为后续追踪奠定坚实基础。 稳定目标追踪：集成SORT（Simple Online and Realtime Tracking）算法，结合卡尔曼滤波器预测车辆未来位置，同时运用匈牙利算法优化目标间的匹配，实现连续、稳定的车辆追踪，有效应对遮挡、交叉等复杂场景。 智能车流量统计：借鉴虚拟线圈概念，巧妙设计算法以监测穿越预设区域的车辆，自动计数并准确统计各车道车流量，为交通管理与分析提供可靠数据支持。 整体而言，本项目通过融合先进的目标检测与追踪技术，结合创新的流量统计方法，构建了一个高效、精准的实时车辆跟踪与流量统计系统，为智慧交通领域的发展贡献力量。
本科毕业设计--基于深度学习的人脸面部表情识别.zip
最新发布
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
雷电模拟器改成真机环境
09-21
在Android系统中，模拟器通常会被识别为非真实的设备，这可能导致某些应用或服务无法正常运行，尤其是那些需要硬件信息或root权限的应用。改真机环境意味着通过技术手段使模拟器的行为更接近真实的Android设备，包括模拟设备硬件信息、IMEI、MAC地址等，以绕过检测并提升兼容性。LSPSED（Linux System Property Setter and Editor）模块是Magisk的一个扩展，专门用于修改Android系统的系统属性。通过LSPSED，我们可以更改设备的各种系统属性，如设备型号、制造商信息等，这些修改对于使模拟器看起来更像真实设备至关重要。在使用过程中，还需要添加几个机型模块，这些模块通常包含了特定设备的系统配置信息，如设备代号、硬件信息等。通过安装这些模块，雷电模拟器可以模仿各种流行的Android设备，进一步提高应用的兼容性和真实性。
教材P139算法7.7求解图7.7(a)所示背包问题
09-19
### 回答1： 好的，让我们来看一下这个问题。 首先，我们需要将问题转化为标准的背包问题形式。图7.7(a)所示的问题中，每个物品有两个属性：重量和价值。我们可以将这两个属性分别作为背包问题中的物品重量和价值。然后再将每个物品拆分成多个子物品，每个子物品的重量都是原来物品的重量的一半。这样，我们就得到了标准的背包问题形式。 接下来，我们可以使用动态规划算法来解决这个问题。设 $f(i,j)$ 表示前 $i$ 个物品放入容量为 $j$ 的背包中所能获得的最大价值。状态转移方程为： $$ f(i,j) = \max\{f(i-1,j), f(i-1,j-w_i)+v_i, f(i-1,j-w_i/2)+v_i, f(i-1,j-w_i/2)-w_i/2+v_i, f(i-1,j-w_i)+w_i/2+v_i\} $$ 其中，$w_i$ 和 $v_i$ 分别表示第 $i$ 个物品的重量和价值。这个状态转移方程中的五个值分别表示不选第 $i$ 个物品、选第 $i$ 个物品、选第 $i$ 个物品的一半、不选第 $i$ 个物品的一半、选第 $i$ 个物品的一半并补足另一半的情况。 最终，我们的目标是求解 $f(n,W)$，其中 $n$ 表示物品的个数，$W$ 表示背包的容量。根据状态转移方程，我们可以使用一个二维数组来存储所有的状态值，然后在数组中查找 $f(n,W)$ 的值即可。 代码实现如下： ### 回答2： 算法7.7是用于求解0-1背包问题的动态规划算法。图7.7(a)表示了背包问题的具体示例，其中有4个物品，它们的重量和价值分别为： 物品1：重量为2，价值为3 物品2：重量为3，价值为4 物品3：重量为4，价值为5 物品4：重量为5，价值为6 背包的容量为10，我们需要确定如何选择物品以使得背包中的总价值最大化。 首先，我们创建一个动态规划表格，表格的行表示物品，列表示背包容量。表格中的每个单元格表示当只考虑前i个物品，并且背包容量限制为j时的最大总价值。 具体的计算过程如下： 1. 初始化动态规划表格。这里我们需要一个5x11的表格来记录结果，其中行0和列0都初始化为0。 2. 对于每一个物品i，从1到4，依次进行如下操作： a) 对于每个背包容量j，从1到10，依次进行如下操作： - 如果物品i的重量wi大于当前背包容量j，则将表格中的当前单元格值设为表格中上一个单元格的值，即dp[i][j] = dp[i-1][j]； - 否则，将表格中的当前单元格值设为上一个单元格值和（上一个单元格对应的背包容量减去物品i的重量的单元格值加上物品i的价值）中的较大值，即dp[i][j] = max(dp[i-1][j], dp[i-1][j-wi] + vi)。 3. 最终，我们可以在动态规划表格的右下角找到最大总价值，即dp[4][10]，它的值为11。 因此，根据算法7.7求解图7.7(a)所示背包问题的结果为最大总价值为11。 ### 回答3： 图7.7(a)所示的背包问题可以用算法7.7来求解。下面是具体的求解过程： 首先，我们需要定义问题的背包容量和物品的价值、重量。根据图7.7(a)，背包的容量为10，物品的价值和重量分别为[6, 5, 8, 9, 6]和[2, 3, 6, 7, 5]。 接下来，我们创建一个动态规划的二维数组dp，其中dp[i][j]表示前i个物品在容量为j的背包中的最大价值。初始化dp的第一行和第一列为0。 然后，我们利用动态规划的思想，从上至下、从左至右地填充dp数组。对于每一个位置dp[i][j]，我们有两种选择：放入物品i或者不放入物品i。如果选择放入物品i，那么dp[i][j]的值为dp[i-1][j-w[i]] + v[i]，表示当前背包容量减去物品i重量后的容量所能得到的最大价值再加上物品i的价值。如果选择不放入物品i，那么dp[i][j]的值为dp[i-1][j]。我们选择较大的值作为dp[i][j]的值。 最后，遍历完所有的物品和背包容量，dp数组的右下角的值dp[n][C]即为所求背包问题的最优解，其中n为物品的数量，C为背包的容量。 在本例中，计算完dp数组所有的值后，我们得到dp[5][10]的值为24。这说明，在背包容量为10的情况下，从这些物品中选择一些放入背包，能够得到的最大总价值为24。 因此，根据算法7.7的求解过程，图7.7(a)所示的背包问题的最优解为24。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值