2嗯嗯呢呢

这篇博客探讨了多个算法问题,包括01背包问题的求解,通过深度优先搜索实现;活动安排的最大兼容子集计算;快速排序算法的详细步骤;棋盘覆盖问题的递归解决方案;以及图论中的最短路径算法Floyd-Warshall。这些内容涵盖了数据结构和算法的基础与应用。
摘要由CSDN通过智能技术生成

01背包

   void dfs(int i,int tw,int tv,int rw,int op[]) //求解0/1背包问题
{
int j;
if (i>n) //找到一个叶子结点
{ if (tw==W && tv>maxv) //找到一个满足条件的更优解,保存它
{ maxv=tv;
for (j=1;j<=n;j++) //复制最优解
x[j]=op[j];
}
}
else //尚未找完所有物品
{ if (tw+w[i]<=W) //左孩子结点剪枝:满足条件时才放入第i个物品
{
op[i]=1; //选取第i个物品
dfs(i+1,tw+w[i],tv+v[i],rw-w[i],op);
}
op[i]=0; //不选取第i个物品,回溯
if (tw+rw>W) //右孩子结点剪枝
dfs(i+1,tw,tv,rw-w[i],op);
}
}

活动安排

 void solve() //求解最大兼容活动子集
{
memset(flag,0,sizeof(flag));//初始化为false
sort(A,A+n); //A[1..n]按活动结束时间递增排序
int preend=0; //前一个兼容活动的结束时间
 for(int i=0;i<=n;i++)
 { if (A[i].b>=preend)
{ flag[i]=true;
preend=A[i].e;
}
}
}
快排

  int Partition(SqList &L,int low,int high)
{
 int pivotkey;
 L.r[0]=L.r[low];
 pivotkey=L.r[low].key;
 while(low<high)
 {
  while(low<high&&L.r[high].key>=pivotkey)
   high--;
  L.r[low]=L.r[high];
  
  while(low<high&&L.r[low].key<=pivotkey)
   low++;
  L.r[high]=L.r[low];
  
 }
 L.r[low]=L.r[0];
 return low;
}
void QSort(SqList &L,int low,int high)
{
 int pivotloc;
 if(low<high)
 {
  pivotloc=Partition(L,low,high);
  QSort(L,low,pivotloc-1);
  QSort(L,pivotloc+1,high);
 }
}

棋盘

 void ChessBoard(int tr,int tc,int dr,int dc,int size)
{ //tr和tc是棋盘左上角的下标,dr和dc是特殊方格的下标,size是棋盘的大小
    int t=0;
    int s;
 
    if (size==1)return;
    
    t=tile++;
    s=size/2; //划分棋盘
    
    //覆盖左上角棋盘
    if (dr<tr+s&&dc<tc+s)  //特殊方格在棋盘的左上角
        ChessBoard(tr,tc,dr,dc,s);
    else
    {
        board[tr+s-1][tc+s-1]=t;
        ChessBoard(tr,tc,tr+s-1,tc+s-1,s);
    }    
    //覆盖右上角棋盘
    if (dr<tr+s&&dc>=tc+s)  //特殊方格在棋盘的右上角
        ChessBoard(tr,tc+s,dr,dc,s);
    else
    {
        board[tr+s-1][tc+s]=t;
        ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
    }    
    //覆盖左下角棋盘
    if (dr>=tr+s&&dc<tc+s)    //特殊方格在棋盘的左下角
        ChessBoard(tr+s,tc,dr,dc,s);
    else
    {
        board[tr+s][tc+s-1]=t;
        ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
    }    
    //覆盖右下角棋盘
    if (dr>=tr+s&&dc>=tc+s) //特殊方格在棋盘的右下角
        ChessBoard(tr+s,tc+s,dr,dc,s);
    else
    {
        board[tr+s][tc+s]=t;
        ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
    }
}
 

生成树

 #include<bits/stdc++.h>
using namespace std;
int cmp(Evode a,Evode b)
{
    return a.lowcost<b.lowcost;
}

int find(char x)//找父亲
{
    int y;
    y = int(x)-int('0');
    while(Vexset[y]!=y)y=Vexset[y];
    return y;
}

int add(char x,char y)//判断是否为同一个父亲,不是就加到一起
{
    if(find(x)==find(y))return 0;
    else
    {
        int fx = find(x);
        int fy = find(y);
        Vexset[fx]=fy;
        return 1;
    }
}

void Kruskal(AMGraph G)
{
    for(int i=0;i<G.vexnum;i++)
    {
        Vexset[int(G.vexs[i])-int('0')]=int(G.vexs[i])-int('0');//开始的父亲就是自己
    }
    
    sort(Edge,Edge+G.arcnum,cmp);//按结构体中路径长短排序
    
    for(int i=0;i<G.arcnum;i++)
    {
        if(add(Edge[i].Head,Edge[i].Tail))
        {
           printf("%c->%c\n",Edge[i].Head,Edge[i].Tail);
        }

    }
}
 

长子序列

   void IncreaseOrder(int a[],int dp[],int x[][N],int n)
{
int i, j, k, index;

for (i = 0; i < n; i++) //依次计算a[0]~a[i]的最长递增子序列
{
dp[i] = 1;
x[i][0] = a[i];
int max = 1;
int maxindex=i; //初始化递增子序列长度的最大值
    for(int j = 0;j < i;j ++) {
if ((a[j] < a[i]) && (max<dp[j]+1)){
 
max = dp[j]+1;
maxindex=j;
}
}
if(maxindex!=i){
dp[i] = max;
for (k = 0; k < max-1; k++) //存储最长递增子序列
x[i][k] = x[maxindex][k];
x[i][max-1]= a[i];
}
}
}

着色

 void dfs(int i)                    //求解图的m着色问题
{
    if (i>n)                    
    {
        
count++ 
;            
    }
    else
    {
        for (int j=1;j<=m;j++)    
        {
            x[i]=j;
            if (
Same(i)
)        
                dfs(i+1);
            
x[i]=0
;            
        }
    }
}

最短路

 void ShortestPath_Floyed(AMGraph G){ 
    int i , j , k ;
    for (i = 0; i < G.vexnum; ++i)
        for(j = 0; j < G.vexnum; ++j){ 
            D[i][j] = 
G.arcs[i][j]

            if(D[i][j] < MaxInt && i != j) 
Path[i][j]=i

            else Path [i][j] = -1; 
        }
    for(k = 0; k < G.vexnum; ++k) 
        for(i = 0; i < G.vexnum; ++i) 
            for(j = 0; j < G.vexnum; ++j)
                if(
D[i][k] + D[k][j]
 < D[i][j]){
                    D[i][j] = 
D[i][k]+D[k][j]
;
                    Path[i][j] =
Path[k][j]

                }
}

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值