qq_50675813的博客

动态规划解决问题是自底向上。原问题的规模是n个元素。这n个元素不好考虑，我们先考虑n-1个元素，这样还不好考虑，我们考虑n-2个元素，这样依次递减，最后问题规模变成一个元素。但是我们发现，在递减的过程中间，子问题的最优解包含在原问题的最优解之中，而且子问题的解还有一些是重复的。因此，使用动态规划来解决这个问题。思想：对字段序列进行一个循环，如果之前的序列b>0，则加入这个新的序列之中；如果之前的序列b<=0,则重新设置字段的序列和为nums[i]；如果之前的序列加上nums[

【问题描述】最近对问题要求在包含有n个点的集合S中，找出距离最近的两个点。设 p1(x1,y1)，p2(x2,y2)，……，pn(xn,yn)是平面的n个点。严格地将，最近点对可能不止一对，此例输出一对即可。【基本算法思想】暴力法：在蛮力法实现最近点对问题中，将问题简化：距离最近的点对可能多于一对，找出一对即可，另外只考虑二维平面中的情况。此处考虑到直接用公式计算其距离（欧几里得距离）：通过遍历所有点集，计算出每一个点对的距离，计算出最近的距离并输出。避免同一对点计算两次，只考虑i<

#include<iostream>#include<queue>//优先队列的头文件using namespace std;//子集树中节点的定义class bbnode{ public: bbnode *parent;//指向父节点的指针 bool Lchild;//是否是左孩子结点的标记 };//优先队列中节点的定义 class HeapNode{ public: bbnode *ptr; //指向活结点在子集树中相应节点的指针 int u

算法设计与分析——递归与分治策略——全排列#include<bits/stdc++.h>using namespace std;int number=0;void arrange(vector<int> &nums,int left,int right){ if(left==right) { for(auto a:nums) { cout << a << " ";

汽车加油问题：一辆汽车加满油后可行驶n公里，旅途中有若干个加油站，两加油站间距离不超n 公里，起点离第一个加油站距离及最后一个加油站离终点距离也不超过n公里。算法给出应在哪些加油站停靠加油，使沿途加油次数最少。图中两端表示汽车起点和终点，中间标志为k个加油站，每段距离分别为s[0],s[1] ……s[k]公里.#include<iostream>using namespace std;int main(){ int n; cout<<"输入一次加油后可以行使的距

#include<iostream>#include<iomanip>using namespace std;//前i个物品装入容量为j的背包中获得的最大价值//0-1背包动态规划算法 构造二维表int knapsack_problem( int n,int *weight,int *value,int capacity,int **m,int *flag){ for(int i=0;i<=capacity;i++)//赋值第一行 为0 { m[0

#include<iostream>#include<queue>#include<cmath>#include<vector>#include<fstream>#include<sstream>using namespace std; //定义一个节点类struct Node{ int number; vector<int>x;//保存当前解 }; //定义一个Queen的类 class Q

#include<bits/stdc++.h>using namespace std;vector<int> vec;void copy(vector<int> &nums, vector<int> &vec, int left, int right);void Merge(vector<int> &nums, vector<int> &vec, int left, int mid, int r

#include<iostream>using namespace std;void activity_arrangement(int n,int start[],int final[],bool result[]){ //先按活动的结束时间排好序 int temp; result[1]=true; temp=1; for(int i=2;i<=n;i++) { if(final[temp]<=start[i]) { result[i

#include<iostream>#include<algorithm>#include<cstring>using namespace std;typedef struct Node{ float value; float weight; float vw;//单位重量的价值 }node;bool cmp(node x,node y){ if(x.vw>y.vw)//从大到小排序 return true; else retu

#include<iostream>#include<bits/stdc++.h>using namespace std;const int noEdge=65535;class Traveling{ public: void BackTrack(int i); int n; //图G的顶点数 int *x; //当前的解 int *bestx; // 当前的最优解 int **a; // 图G的临界矩阵 int cc;

问题描述：非递归方案一：代码#include<bits/stdc++.h>using namespace std;void gameTable(vector<vector<int>> &vec,int k){ int i=0,j=0;//二维数组的下标，行，列 int temp;//需要新安排选手数目 int n;//当前的选手数目 //先初始化一个两人的比赛表 n=2; //k=1两个参赛选手日程可以直接求得 vec[1]

1、分治法分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同。递归的解这些子问题，然后将各子问题的解合并得到原问题的解。分治法所能解决的问题一般具有以下几个特征：　 1) 该问题的规模缩小到一定的程度就可以容易地解决　 2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。　 3) 利用该问题分解出的子问题的解可以合并为该问题的解；　 4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。分治法的基

1.打水问题：有n个人去水房排队打水，只有一个出水口，且出水口流速恒定。每个人因为盛水的工具不一，打水所需的时间也不一致，设第i个人所需要的打水时间为ti；问如何安排打水顺序使得所有人的平均等待时间最短。#include<iostream>#include<bits/stdc++.h>using namespace std;typedef struct Node{ int i; int time;}node;bool cmp(node x,node y){

暴力法：#include<iostream>using namespace std;int MaxSum(int n,int *a,int &besti,int &bestj){ int sum=0; for(int i=0;i<n;i++) { for(int j=i;j<n;j++) { int tempSum=0; for(int k=i;k<j;k++) { tempSum+=a[k]; if(t

//0-1背包问题 回溯法求解#include<bits/stdc++.h>#include <iostream>using namespace std; template<class Typew,class Typep>class Knap{ public: Typep Bound(int i); void Backtrack(int i); Typew c; //背包容量 int n; //物品数 Typew *w; //.

有一批集装箱要装上一艘载重量为c的轮船。其中集装箱i的重量为Wi。最优装载问题要求确定在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船。#include<iostream>#include<algorithm>#include<cstring>using namespace std;typedef struct Node{ int number;//序列中的第几个 int weight;//序列的重量 }node;bool cmp(node

印刷电路板将布线区域划分成n×m个方格如图a所示。精确的电路布线问题要求确定连接方格a的中点到方格b的中点的最短布线方案。在布线时，电路只能沿直线或直角布线，如图b所示。为了避免线路相交，已布了线的方格做了封锁标记，其它线路不允穿过被封锁的方格。一个布线的例子：图中包含障碍。起始点为a，目标点为b。算法思想：解此问题的队列式分支限界法从起始位置a开始将它作为第一个扩展结点。与该扩展结点相邻并且可达的方格成为可行结点被加入到活结点队列中，并且将这些方格标记为1，即从起始方格a到这些方格的距离为1。

问题描述：给定n个作业的集合{J1,J2,…,Jn}。每个作业必须先由机器1处理，然后由机器2处理。作业Ji需要机器j的处理时间为tji。对于一个确定的作业调度，设Fji是作业i在机器j上完成处理的时间。所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。批处理作业调度问题要求对于给定的n个作业，制定最佳作业调度方案，使其完成时间和达到最小。这3个作业的6种可能的调度方案是1,2,3；1,3,2；2,1,3；2,3,1；3,1,2；3,2,1；它们所相应的完成时间和分别是19，18，20，2

#include<iostream>#include<bits/stdc++.h>using namespace std;int tile = 1;int Borad[100][100];void ChessBoard(int tr,int tc,int dr,int dc,int size){ if(size==1) return; int t = tile++; int s = size / 2; if( dr<

顾名思义：这篇文章讲解的就是如果用线性时间算法来作出元素选择问题。问题描述：给定线性序集中n个元素和一个整数k，1<=k<=n.要求找出这n个元素中第k小的元素，即如果将这个n个元素依其线性序排列时，排在第k个位置的元素就是要找的元素，当k== 1时，要找的就是最小的元素；当k==n，就是最大的元素；当k=（n+1）/2，称为中位数。问题分析：在某些特殊的情况下，我们可以实现线性时间选择，对于找最大最小的元素O(n)内可以实现；当k<=n/logn,通过堆排序算法可以在O(n+klo

将正整数n表示为一系列正整数之和， n=n1+n2+n3+n4+......+nk （其中，n1>=n2>=n3>=n4........>=nk>0,k>=1）正整数n的这种表示成为正整数n的划分。正整数n的不同划分个数成为正整数n的划分数，记作p（n）。例如，正整数6有如下11种划分:6;5+1;4+2,4+1+1;3+3,3+2+1,3+1+1+1;2+2+2,2+2+1+1,2+1+1+1+1;1+1+1+1+1+1;其实这种问题可

一、什么是N皇后问题？在n×n格的棋盘上放置彼此不受攻击的n个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。n后问题等价于再n×n的棋盘上放置n个皇后，任何2个皇后不妨在同一行或同一列或同一斜线上。#include<iostream>using namespace std;class Queen{ public: bool Place(int k); void Backtrack(int t); int n;//皇后的个数 in

动态规划与分治法的异同：相同点：其基本思想都是将待求解问题分解为若干子问题，先求解子问题，再结合这些子问题的解得到原问题的解。差异点：与分治法不同的是，适合用动态规划法求解的问题经分解得到的子问题往往不是相互独立的。有些问题分解后的子问题往往是重复的，此时若用分支法则会重复计算耗费时间内存。总结：为了达到避免重复计算，可以用一个表来记录所有已解决的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。步骤：找出最优解的性质，刻画其结构特征。递归地定义最优值。以自底向上的

快速排序——递归算法#include<iostream>#include<bits/stdc++.h>using namespace std;vector<int> vec;int partition(vector<int> &vec,int left,int right);void QuickSort(vector<int> &vec,int left,int right){ if(left<right)

0027算法笔记——【回溯法】回溯法与装载问题自己写的代码：#include <iostream>using namespace std; template <class Type>class Loading{ //friend Type MaxLoading(Type[],Type,int,int []); //private: public: void Backtrack(int i); int n, //集装箱数 *x

#include<stdio.h>#include<stdlib.h>#include<iostream>#include<algorithm>using namespace std;typedef struct Node{ int hour;//记录该作业的所需要完成的时间 int number;//记录该作业在原来的序列的顺序}node;bool cmp(node x,node y){ if(x.hour>y.hour)

**汉诺塔问题：**古代有一个梵塔，塔内有三个座A、B、C，A座上有64个盘子，盘子大小不等，大的在下，小的在上（如图）。有一个和尚想把这64个盘子从A座移到B座，但每次只能允许移动一个盘子，并且在移动过程中，3个座上的盘子始终保持大盘在下，小盘在上。我们的移动盘子的步骤为：• 如果只有 1 个盘子，则不需要利用B塔，直接将盘子从A移动到C。• 如果有 2 个盘子，可以先将盘子1上的盘子2移动到B；将盘子1移动到C；将盘子2移动到C。这说明了：可以借助B将2个盘子从A移动到C，当然，也可以借助C将2个.

#include<iostream>#include<math.h> using namespace std;class Circle{ public: float Center(int t); void Compute(void ); void BackTrack(int t); float min; //当前最优值 float *x; //当前圆排列圆心横坐标 float *r; //当前圆排列 float *resu

#include<iostream>#include<stdio.h>#include<string.h>#include<bits/stdc++.h>#define MAXLEN 50using namespace std;void LCSlength(int m,int n,char *x,char *y,int c[][MAXLEN],int b[][MAXLEN]){ for(int i=0;i<=m;i++)//...

#include<iostream>using namespace std;class Triangle{ public: void Backtrack(int t); int n;//第一行的符号个数 int half;//n*(n+1)/4 int count;//当前—的个数 int **p;//符号三角形矩阵 long sum; //已找到的符号三角形数 };void Triangle::Backtrack(int t){ if(

十大经典排序算法最强总结