花开无言

#include using namespace std;#define N 110int matrix[N][N];int maxSubArray(int* array, int n){    int maxSum = INT_MIN;    int tempSum = 0;    for (int i = 0; i     {        te

#include #include using namespace std;bool isUniqueChars(string str){    if (str.size() > 256)//假设字符串为ASCII码，最多256个字符    {        return false;    }    bool char_set[256];    mem

#include #include #include using namespace std;struct Node{    int data;    Node* next;};Node* partition(Node* head, int x){    Node* beforeS = NULL;    Node* beforeE = NUL

#include #include #include using namespace std;struct Node{    int data;    Node* next;};void delDuplicate(Node* head){    map table;    Node* pre = NULL;    while (head)

#include #include #include using namespace std;struct Node{    int data;    Node* next;};Node* addLists(Node* n1, Node* n2, int carry){    if (!n1 && !n2 && !carry)    { 

#include #include #include #include using namespace std;struct Node{    int data;    Node* next;};bool isPalindrome(Node* head){    Node* slow = head;    Node* fast = hea

#include #include using namespace std;void replaceSpace(char str[], int len){    int spaceCount = 0;    int newLen = 0;    for (int i = 0; i     {        if (str[i] == ' ')      

#include #include #include #include using namespace std;int stackSize = 100;int* buffer = new int[stackSize * 3];int stackPointer[3] = {-1, -1, -1};void push(int stackNum, int valu

#include #include #include #include using namespace std;template class StackWithMin{public:    StackWithMin(void) {}    T& top(void);    void push(const T& value);    void pop

#include #include using namespace std;int maze[4][4] = {1,1,1,0,1,1,0,1,1,1,1,1,0,0,1,1};//0表示障碍，1表示可以通过struct Point{ int x; int y;};bool getPath(int x, int y, list& path){ Poin

#include #include #includeusing namespace std;int maze[4][4] = {1,1,1,0,1,1,0,1,1,1,1,1,0,0,1,1};//0表示障碍，1表示可以通过struct Point{ int x; int y; bool operator < (const Point& p) cons

#include #includeusing namespace std;const int INF = 10000000;typedef pair P;//保存状态，即点的位置//迷宫，'#'表示墙壁， '.'表示通道，S表示起点，G表示终点char maze[10][10] = { '#','S','#','#','#','#','#','#','.','#',

#include using namespace std;int binarySearch1(int a[], int n, int x) //[l, u)区间{ int l, u, m; l = 0; //左区间闭合 u = n; //右区间开放 while(l < u) //用<做判断，不用<= { m =

//求取所有的最长公共子序列 #include using namespace std; const int X = 100, Y = 100; //串的最大长度 char result[X+1]; //用于保存结果 int count = 0;

#include #include #include #include using namespace std; const int N = 10; int arr[N]; /******************快速排序稳定版本******************************

1、问题描述已知:有一个容量为V的背包和N件物品，第i件物品的重量是weight[i]，收益是cost[i]。条件:每种物品都有无限件，能放多少就放多少。问题:在不超过背包容量的情况下，最多能获得多少价值或收益举例：物品个数N = 3，背包容量为V = 5，则背包可以装下的最大价值为40.---------------------------------------------

#include #include using namespace std;vector > getSubset(vector& set){ vector > res; res.clear(); int max = 1 << set.size(); for (int i = 0; i < max; i++) { vector sub

#include using namespace std;void print_permutation(int n, int* arr, int cur){ if (cur == n) { for (int i = 0; i < n; i++) { printf("%d ", arr[i]); }

#include using namespace std;int getNext(int n){ int t = n; int c0 = 0; int c1 = 0; while ((t & 1) == 0 && (t != 0)) { c0++; t >>= 1; } while ((t & 1) == 1) { c1++; t >>= 1; } if

#include using namespace std;/*input： 正整数n（32位）return：比n小，最接近n，而且二进制中1的个数与n相同（当然，0的个数也就相同了） 算法思想：从右往左找到第一个1，他的右边是0，记录下他右边1和0的个数，分别为x和y,对于返回的结果，这个1左边的位肯定不变，不用考虑，把这个1变成0，这样数字变小，同时0的个数+1，1的个数-1，为

#include using namespace std;/*算法思想：先把两个数字异或，异或的结果中有几个1就表示有这些位不同，即，改变这些位（1变成0，0变成1）就能使他们相同，此外，使用（c & (c - 1)）可以使c的最低有效位（1的位）变成0*/int bitNeedChanged(int a, int b){ int count = 0; for (int c

#include using namespace std;int swapOddAndEvenBits(int x){ return ( ((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));//用不同的掩码分别提取奇数位与偶数位，奇数位右移1位变成偶数位，偶数位左移1位变成奇数位，然后按位或}int main(){ cout

//判断一个数字的某一位是不是1bool getBit(int num, int i){ return num & (1 << i);}//把一个数字的某一位置1int setBit(int num, int i){ return num | (1 << i);}//把一个数字某一位置0int clearBit(int num, int i){ in

#include using namespace std;void primeFilter(int max){ bool* flags = new bool[max + 1]; flags[0] = flags[1] = false; for (int i = 2; i <= max; i++) { flags[i] = true;

#include using namespace std;//DP的思想不过是缓存中间结果，消除递归带来的重复计算，以空间换时间罢了int fib[1000] = {0};//初始化为0，当然，不同场景下dp初始化不同int fibonacci(int i){ if (i <= 1)//边界 { return i; } if (fib[i

#include using namespace std;int total = 0;const int n = 8;int col[n];void search(int cur){ if (cur == n) { total++; } else { for (int i = 0; i < n; i++)

#include #include using namespace std;int min(int a, int b){ return a < b ? a : b;}int getKthNumberBy357(int k){ if (k < 0) { return 0; } int v = 0; queue q3,

#include #include using namespace std;int maze[4][4] = {1,1,1,0,1,1,0,1,1,1,1,1,0,0,1,1};//0表示障碍，1表示可以通过struct Point{ int x; int y;};bool getPath(int x, int y, list& path){ Poin

#include #include #include #include #include using namespace std;typedef int graph_weight_t;typedef char graph_vertex_id_t;struct graph_t { int nv; int ne; map > matrix;};/**

#include #include /* for INT_MAX */#include #include using namespace std;/** 顶点数的最大值*/const int MAX_NV = 100;/** 边的权值，对无权图，用0 或1 表示是否相邻；对有权图，则为权值. */typedef int graph_weight_t;const graph_we

#include #include // for INT_MAX#include using namespace std;/** 顶点数的最大值*/const int MAX_NV = 100;/** 边的权值，对无权图，用0 或1 表示是否相邻；对有权图，则为权值. */typedef int graph_weight_t;const graph_weight_t GRAPH_

#include #include /* for INT_MAX */#include #include using namespace std;#include /** 并查集. */typedef struct ufs_t { int *p; /** 树的双亲表示法*/ int size; /** 大小. */} ufs_t;/*** @brief 创建

#include /** 并查集. */typedef struct ufs_t { int *p; /** 树的双亲表示法*/ int size; /** 大小. */} ufs_t;/*** @brief 创建并查集.* @param[in] n 数组的容量* @return 并查集*/ufs_t* ufs_create(int n) { ufs_t

template class SmartPointer{public: SmartPointer(T* ptr) { ref = ptr; ref_count = (unsigned*)malloc(sizeof(unsigned)); *ref_count = 1; } SmartPointer(SmartPointer& sptr) { ref = sptr.r

#include #include using namespace std;int countAtSomeDigit(int num, int d) //0到num之间，第d位2的个数{ int powerOf10 = (int)pow(10.0, d); int nextPower = powerOf10 * 10; int right = num % powerOf10; i

#include #include using namespace std;/*使用位向量法解决，分成两次扫描文件，按照内存大小把数据分成若干块，第一次扫描找到哪一块包含缺少的数据，第二次扫描找到那一块的位置*/void findNumber(){ int bitSize = 1024 * 1024; //每块存放2的20次方bit数据 int blockNum = 4096

[有向图强连通分量]在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分

#include #include /* for INT_MAX */using namespace std;/** 顶点数最大值. */const int MAX_NV = 100;/** 边的权值类型，可以为int, float, double. */typedef int graph_weight_t;const graph_weight_t GRAPH_INF = INT_

为了能够求解含负权边的带权有向图的单源最短路径问题，Bellman(贝尔曼)和Ford(福特)提出了从源点逐次绕过其他顶点，以缩短到达终点的最短路径长度的方法。不能处理带负权边的无向图。图中不能包含权值总和为负值回路(负权值回路)。递推公式(求顶点u到源点v的最短路径)：dist 1 [u] =Edge[v][u]dist k [u] =min{distk-1 [u],

SPFA  全称 Shortest Path Faster Algorithm基本应用为快速求解单源最短路用该算法判断图中是否存在负权环（POJ3259）：若一个点最短路被改进的次数达到n，则有负权环#include #include #include #include using namespace std;int F,N,M,W;const int INF = 1 <<