Edwards_June的专栏

在一个平面坐标系上，有两个矩形，它们的边分别平行于X和Y轴。其中，矩形A已知， ax1(左边), ax2（右边）, ay1（top的纵坐标）, ay2（bottom纵坐标）. 矩形B，类似，就是 bx1, bx2, by1, by2。这些值都是整数就OK了。要求是，如果矩形没有交集，返回-1， 有交集，返回交集的面积。int area(rect const& a, rect const

#include using namespace std;/*函数作用：取待排序序列中low、mid、high三个位置上数据，选取他们中间的那个数据作为枢轴*/int median(int arr[], int b[], int len1, int low, int high) { int mid = low + ((high - low) >> 1); //计算数组中间的元素的下标

二重歌德巴赫猜想所有大于等于6的偶数都可以表示成两个（奇）素数之和。给定1-10000，找到可以用两个素数之和表示每一个偶数的两个素数，然后输出这两个素数，如果有多对，则只需要输出其中之一对即可。#define N 10000//素数判断bool isOddPrime(int num) { for (int i = 2; i < num / 2; ++i) { if (nu

#define N 4/* * 公式： * f(n) = 2^((n - 1) ^2) */int calWays(int n) { int mutiNum = (n - 1) * (n - 1); int result = 1; for (int i = 0; i < mutiNum / 2; ++i) { result *= 2; } result *= result

#define RANGE 10000int* sort(int* arr, int len) { int* hashtable = new int[len]; memset(hashtable, 0, sizeof(int) * len); for (int i = 0; i < len; ++i) { hashtable[arr[i]]++; } return hashtab

//时间复杂度O(n),空间复杂度O(n)void findSequence(int* arr, int len) { int* hashtable = new int[RANGE]; memset(hashtable, 0, RANGE); for (int i = 0; i < len; ++i) { hashtable[arr[i]] = 1; } cout << "(a

#include using namespace std;#define Max 5 //维数int orgin[Max][Max]; //原始矩阵int sub[Max][Max]; //归约矩阵int draw[Max][Max]; //0:未被画线 1:画了1次 2: 画了2次(交点)int row0[Max], col0[Max];

void knuth(int n, int m) { srand((unsigned) time( NULL)); for (int i = 0; i < n && m; i++) { //满足限定条件:rand() % (n - i) < m,即输出i,i递增不重复 if (rand() % (n - i) < m) { cout << i << "\t"; m--;

int binaryFind(int* arr, int low, int high, int target) { while (low <= high) { int middle = (low + high) >> 1; //(low+high)/2 if (arr[middle] == target) return middle; //在右半边 else if (

int findInc(int* arr, int len) { if (!arr || !len) { return 0; } int* count = new int[len]; int sum = 0; for (int i = 0; i < len; ++i) { count[i] = 0; for (int j = i; j >= 0; --j) { if

请自己用双向链表实现一个队列，队列里节点内存的值为int，要求实现入队，出队和查找指定节点的三个功能。#include using namespace std;typedef struct node { int data; node* prev; node* next;} Node;typedef struct queue { Node* front; Node* rea

n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始，每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。当一个数字删除后，从被删除数字的下一个继续删除第m个数字。求出在这个圆圈中剩下的最后一个数字。#include using namespace std;//最后剩下元素位置int lastRemaining(int n, int m) {

#include using namespace std;int cal1From0ToN(int n) { int pow1 = 1; int pow2 = 10; int count = 0; while (n / pow1) { switch (n % pow2 / pow1) { case 0: count += n / pow2 * pow1; brea

提示：可以采用两两比较的思路。int findMid(int* arr, int len) { if (arr[0] <= arr[1]) { if (arr[1] <= arr[2]) { return arr[1]; } else { if (arr[0] >= arr[2]) { return arr[0]; } else { return a

int findMinAbsValue(int* arr, int len) { int min = INT_MAX; for (int i = 1; i < len; ++i) { if (abs(arr[i - 1] - arr[i]) < min) { min = abs(arr[i - 1] - arr[i]); num[0] = arr[i - 1]; num[

int findMinAbsSum(int* arr, int len) { int min = INT_MAX; for (int i = 1; i < len; ++i) { if (abs(arr[i - 1] + arr[i]) < min) { min = abs(arr[i - 1] + arr[i]); nums[0] = arr[i - 1]; nums[

N个整数（数的大小为0-255）的序列，把它们加密为K个整数（数的大小为0-255）.再将K个整数顺序随机打乱，使得可以从这乱序的K个整数中解码出原序列。设计加密解密算法,且要求K如果是：NNN#include using namespace std;void printArray(int* arr, int len) { if (!arr) { retur

对于给定的整数集合S，求出最大的d，使得a+b+c=d。a,b,c,d互不相同，且都属于S。集合的元素个数小于等于2000个，元素的取值范围在[-2^28，2^28 - 1]，假定可用内存空间为100MB，硬盘使用空间无限大，试分析时间和空间复杂度，找出最快的解决方法。提示：两两相加转为多项式乘法，比如(1 2 4 6) + (2 3 4 5) => (x + x^2 + x^4 + x^6)

如果两个数a和b，a的所有真因数之和等于b,b的所有真因数之和等于a,则称a,b是一对亲和数。 例如220和284，1184和1210，2620和2924。#define N 5000000void findQHNums(int n) { int* sum = new int[n]; memset(sum, 0, n * sizeof(int)); //N内的真因子 for (i

1 1 1 1    1 2 3 2 1  1 3 6 7 6 3 1以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数，左上的数和右上数等3个数之和（如果不存在某个数，认为该数就是0）。求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3。int findEvenIndex(int line) { i

{5 3 1}和{7 5 3}是2组不同的等差三元组，除了等差的性质之外，还有个奇妙的地方在于：5^2 – 3^2 – 1^2 = 7^2 – 5^2 – 3^2 = N = 15。{19 15 11}同{7 5 3}这对三元组也存在同样的性质：19^2 – 15^2 – 11^2 = 7^2 – 5^2 – 3^2 = N = 15。这种成对的三元组还有很多。当N = 15时，有3对，分

void sort(int* arr, int len) { if (!arr) { return; } for (int i = 1; i < len; ++i) { while (arr[0] != 0) { swap(arr[arr[0]], arr[0]); } i = 1; while (i < len) { if (arr[i] == i) {

#include using namespace std;//1亿#define BILL (1000*1000*1000)//用int的32位存储标志: 1亿/32bit#define FLAGS 3125000//随机数个数#define RANCOUNT (1000*10000)#define BIT_SIZE 32void printArray(int* arr

//重叠区间数#define N 2typedef struct arrange { int x; int y;} Arrange;//先按左边界排序,若相等再按右边界排序(升序)int cmp(const void* a1, const void* a2) { if ((*(const Arrange*) a1).x == (*(const Arrange*) a2).x)

完美洗牌问题是两手洗牌，假设有三只手同时洗牌呢？那么问题将变成：输入是a1,a2,……aN, b1,b2,……bN, c1,c2,……cN，要求输出是c1,b1,a1,c2,b2,a2,……cN,bN,aN，这个时候，怎么处理？#include using namespace std;//翻转字符串时间复杂度O(to - from)void reverse(int *a, int fr

一个数组里，数都是两两出现的，但是有三个数是唯一出现的，找出这三个数。#include using namespace std;#define N 3int getLenOfBinary(int num) { int len = 0; while (num) { num = num >> 1; len++; } return len;}int getFirstO

思路: * 每个元素转置前后会形成一个环(一个数字有多个环) * 利用环来移动元素达到转置 * 关键： * 1.得到元素下标的前驱后继, * 2.判断环是否已走过(意味属于一个环的元素一次转置完成) * 解决: * 1.从一维下标转二维坐标得到转置后的二维坐标再换回一维坐标 * 如：M*N矩阵 * 假设转置前某个元素的数组下标为i，则它所在行列为（i/N, i%

提示：双端 LIS 问题，用 DP 的思想可解。#include using namespace std;void printArray(int* arr, int len) { for (int i = 0; i < len; ++i) { cout << arr[i] << ' '; } cout << endl;}int binaryFind(int* lis, i

#include using namespace std;#define M 4#define N 5void init(int* arr, int m, int n) { for (int i = 1; i <= m * n; ++i) { arr[i - 1] = i; }}//定义四个方向的界限,不够优化int* spiralMatrix(int matrix[M]

给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数 要求下排每个数都是先前上排那十个数在下排出现的次数。上排的十个数如下：0，1，2，3，4，5，6，7，8，9举一个例子，数值: 0,1,2,3,4,5,6,7,8,9分配: 6,2,1,0,0,0,1,0,0,00在下排出现了6次，1在下排出现了2次，2在下排出现了1次，3在下排出现了0次....以此类

#define M 3#define N 3//二维坐标和为奇数的元素和与坐标和为偶数的元素和是否相等bool getSum(int matrix[M][N], int m, int n) { if (!matrix) { return false; } int sumA = 0; int sumB = 0; for (int i = 0; i < m; ++i) { f

#define COLS 10#define WAYS 100int col[COLS];int result[WAYS][COLS];bool isVaild(int level) { for (int i = 1; i < level; ++i) { if (col[i] == col[level] || abs(i - level) == abs(col[i] - col[

#define N 10void traverse(bool edge[N][N], int m, int n, int cur, int end, int &result) { if (!m && end == cur) { result++; return; } else if (!m && end != cur) { return; } else { for (in

既然完美洗牌问题是给定输入：a1,a2,a3,……aN,b1,b2,b3,……bN，要求输出：b1,a1,b2,a2,……bN,aN；那么有无考虑过它的逆问题：即给定b1,a1,b2,a2,……bN,aN,，要求输出a1,a2,a3,……aN,b1,b2,b3,……bN ？#include using namespace std;void printArr(int* arr, int

请编程实现矩阵乘法。#include using namespace std;#define M1 3#define M2 3#define N 2//O(N^3)void mulMatix(int matrix1[][N], int matrix2[][M2], int matrix3[][M2]) { for (int i = 0; i < M1; ++i) { for

现有n个红白蓝三种不同颜色的小球，乱序排列在一起，请通过两两交换任意两个球，使得从左至右，依次是一些红球、一些白球、一些蓝球。#include using namespace std;#define R 'R'#define G 'G'#define B 'B'int main() { char arr[] = { G, B, B, G, R, G, R, B }; int

//时间复杂度O(NlogN),空间复杂度O(1)void solution2(int* src, int len) { //先快排,使所有相同项聚集 qsort(src, len, sizeof(int), cmp); int prev = 0; //若带放入元素与上一个放入元素相同则跳过(重复项) for (int i = 1; i < len; ++i) { if (src

N个鸡蛋放到M个篮子中，篮子不能为空，要满足：对任意不大于N的数量，能用若干个篮子中鸡蛋的和表示。写出函数，对输入整数N和M，输出所有可能的鸡蛋的放法。比如对于9个鸡蛋5个篮子解至少有三组：1 2 4 1 11 2 2 2 21 2 3 2 1//篮子数#define M 5//鸡蛋数#define N 9void findFillEgg(int curN

提示：考察比较器int cmp(string str1, string str2) { string nstr1 = str1 + str2; string nstr2 = str2 + str1; return nstr1 < nstr2;}void findMinFromArray(int* arr, int len) { string* strArr = new strin

提示：hash表#include using namespace std;#define N 100#define RANGE 100int* getRandomArray() { int* randomArr = new int[N]; srand(unsigned(time(0))); for (int i = 0; i < N; i++) { randomArr[i