1、队列的最大值
请定义一个队列并实现函数max得到队列里的最大值,要求函数max,push_back,pop_front的时间复杂度都是O(1)。
class Solution {
public:
Solution() : currIndex(0) {}
void push_back(int number)
{
while (!maxisium.empty() && number > maxisium.back().second)
maxisium.pop_back();
data.push_back(pair<int, int>(currIndex, number));
maxisium.push_back(pair<int, int>(currIndex, number));
++currIndex;
}
void pop_front()
{
if (data.front().first == maxisium.front().first)
maxisium.pop_front();
data.pop_front();
}
int max()
{
if(maxisium.empty())
return 0;
return maxisium.front().second;
}
private:
deque<pair<int, int>> maxisium;
deque<pair<int, int>> data;
int currIndex;
};
int main()
{
Solution solution;
solution.push_back(5);
cout << solution.max() << endl;
solution.push_back(4);
cout << solution.max() << endl;
solution.push_back(6);
cout << solution.max() << endl;
solution.pop_front();
cout << solution.max() << endl;
solution.pop_front();
cout << solution.max() << endl;
solution.pop_front();
cout << solution.max() << endl;
}
2、0~n-1中缺失的数字
面试题53(二)
一个长度为n-1的递增排序数组中的所有数字都是唯一的,并且每个数字都在范围0到n-1之内。在范围0到n-1的n个数字中有且只有一个数字不在该数组中,请找出这个数字。
#include<iostream>
#include<string>
#include<vector>
#include <stack>
#include <queue>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unordered_map>
#include <algorithm>
using namespace std;
int GetMissingNumber(const int* numbers, int length)
{
if(numbers == nullptr || length <= 0)
return -1;
int left = 0;
int right = length - 1;
while(left <= right)
{
int middle = (right + left) >> 1;
if(numbers[middle] != middle)
{
if(middle == 0 || numbers[middle - 1] == middle - 1)
return middle;
right = middle - 1;
}
else
left = middle + 1;
}
if(left == length)
return length;
// 无效的输入,比如数组不是按要求排序的,
// 或者有数字不在0到n-1范围之内
return -1;
}
// ====================测试代码====================
void Test(const char* testName, int numbers[], int length, int expected)
{
if(testName != nullptr)
printf("%s begins: ", testName);
int result = GetMissingNumber(numbers, length);
if(result == expected)
printf("Passed.\n");
else
printf("Failed.\n");
}
// 缺失的是第一个数字0
void Test1()
{
int numbers[] = { 1, 2, 3, 4, 5 };
int expected = 0;
Test("Test1", numbers, sizeof(numbers) / sizeof(int), expected);
}
// 缺失的是最后一个数字
void Test2()
{
int numbers[] = { 0, 1, 2, 3, 4 };
int expected = 5;
Test("Test2", numbers, sizeof(numbers) / sizeof(int), expected);
}
// 缺失的是中间某个数字0
void Test3()
{
int numbers[] = { 0, 1, 2, 4, 5 };
int expected = 3;
Test("Test3", numbers, sizeof(numbers) / sizeof(int), expected);
}
// 数组中只有一个数字,缺失的是第一个数字0
void Test4()
{
int numbers[] = { 1 };
int expected = 0;
Test("Test4", numbers, sizeof(numbers) / sizeof(int), expected);
}
// 数组中只有一个数字,缺失的是最后一个数字1
void Test5()
{
int numbers[] = { 0 };
int expected = 1;
Test("Test5", numbers, sizeof(numbers) / sizeof(int), expected);
}
// 空数组
void Test6()
{
int expected = -1;
Test("Test6", nullptr, 0, expected);
}
int main(int argc, char* argv[])
{
Test1();
Test2();
Test3();
Test4();
Test5();
Test6();
return 0;
}
3、数组中数值和下标相等的元素
面试题53(三)
题目:假设一个单调递增的数组里的每个元素都是整数并且是唯一的。请编程实现一个函数找出数组中任意一个数值等于其下标的元素。例如,在数组{-3, -1, 1, 3, 5}中,数字3和它的下标相等。
#include<iostream>
#include<string>
#include<vector>
#include <stack>
#include <queue>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unordered_map>
#include <algorithm>
using namespace std;
int GetNumberSameAsIndex(const int* numbers, int length)
{
if(numbers == nullptr || length <= 0)
return -1;
int left = 0;
int right = length - 1;
while(left <= right)
{
int middle = left + ((right - left) >> 1);
if(numbers[middle] == middle)
return middle;
if(numbers[middle] > middle)
right = middle - 1;
else
left = middle + 1;
}
return -1;
}
// ====================测试代码====================
void Test(const char* testName, int numbers[], int length, int expected)
{
if(GetNumberSameAsIndex(numbers, length) == expected)
printf("%s passed.\n", testName);
else
printf("%s FAILED.\n", testName);
}
void Test1()
{
int numbers[] = { -3, -1, 1, 3, 5 };
int expected = 3;
Test("Test1", numbers, sizeof(numbers) / sizeof(int), expected);
}
void Test2()
{
int numbers[] = { 0, 1, 3, 5, 6 };
int expected = 0;
Test("Test2", numbers, sizeof(numbers) / sizeof(int), expected);
}
void Test3()
{
int numbers[] = { -1, 0, 1, 2, 4 };
int expected = 4;
Test("Test3", numbers, sizeof(numbers) / sizeof(int), expected);
}
void Test4()
{
int numbers[] = { -1, 0, 1, 2, 5 };
int expected = -1;
Test("Test4", numbers, sizeof(numbers) / sizeof(int), expected);
}
void Test5()
{
int numbers[] = { 0 };
int expected = 0;
Test("Test5", numbers, sizeof(numbers) / sizeof(int), expected);
}
void Test6()
{
int numbers[] = { 10 };
int expected = -1;
Test("Test6", numbers, sizeof(numbers) / sizeof(int), expected);
}
void Test7()
{
Test("Test7", nullptr, 0, -1);
}
int main(int argc, char* argv[])
{
Test1();
Test2();
Test3();
Test4();
Test5();
Test6();
Test7();
return 0;
}
4、剪绳子
面试题14:
题目:给你一根长度为n绳子,请把绳子剪成m段(m、n都是整数,n>1并且m≥1)。每段的绳子的长度记为k[0]、k[1]、……、k[m]。k[0]*k[1]*…*k[m]可能的最大乘积是多少?例如当绳子的长度是8时,我们把它剪成长度分别为2、3、3的三段,此时得到最大的乘积18。
#include <iostream>
#include <cmath>
// ====================动态规划====================
int maxProductAfterCutting_solution1(int length)
{
if(length < 2)
return 0;
if(length == 2)
return 1;
if(length == 3)
return 2;
int* products = new int[length + 1];
products[0] = 0;
products[1] = 1;
products[2] = 2;
products[3] = 3;
int max = 0;
for(int i = 4; i <= length; ++i)
{
max = 0;
for(int j = 1; j <= i / 2; ++j)
{
int product = products[j] * products[i - j];
if(max < product)
max = product;
products[i] = max;
}
}
max = products[length];
delete[] products;
return max;
}
// ====================贪婪算法====================
int maxProductAfterCutting_solution2(int length)
{
if(length < 2)
return 0;
if(length == 2)
return 1;
if(length == 3)
return 2;
// 尽可能多地减去长度为3的绳子段
int timesOf3 = length / 3;
// 当绳子最后剩下的长度为4的时候,不能再剪去长度为3的绳子段。
// 此时更好的方法是把绳子剪成长度为2的两段,因为2*2 > 3*1。
if(length - timesOf3 * 3 == 1)
timesOf3 -= 1;
int timesOf2 = (length - timesOf3 * 3) / 2;
return (int) (pow(3, timesOf3)) * (int) (pow(2, timesOf2));
}
// ====================测试代码====================
void test(const char* testName, int length, int expected)
{
int result1 = maxProductAfterCutting_solution1(length);
if(result1 == expected)
std::cout << "Solution1 for " << testName << " passed." << std::endl;
else
std::cout << "Solution1 for " << testName << " FAILED." << std::endl;
int result2 = maxProductAfterCutting_solution2(length);
if(result2 == expected)
std::cout << "Solution2 for " << testName << " passed." << std::endl;
else
std::cout << "Solution2 for " << testName << " FAILED." << std::endl;
}
void test1()
{
int length = 1;
int expected = 0;
test("test1", length, expected);
}
void test2()
{
int length = 2;
int expected = 1;
test("test2", length, expected);
}
void test3()
{
int length = 3;
int expected = 2;
test("test3", length, expected);
}
void test4()
{
int length = 4;
int expected = 4;
test("test4", length, expected);
}
void test5()
{
int length = 5;
int expected = 6;
test("test5", length, expected);
}
void test6()
{
int length = 6;
int expected = 9;
test("test6", length, expected);
}
void test7()
{
int length = 7;
int expected = 12;
test("test7", length, expected);
}
void test8()
{
int length = 8;
int expected = 18;
test("test8", length, expected);
}
void test9()
{
int length = 9;
int expected = 27;
test("test9", length, expected);
}
void test10()
{
int length = 10;
int expected = 36;
test("test10", length, expected);
}
void test11()
{
int length = 50;
int expected = 86093442;
test("test11", length, expected);
}
int main(int agrc, char* argv[])
{
test1();
test2();
test3();
test4();
test5();
test6();
test7();
test8();
test9();
test10();
test11();
return 0;
}
5、礼物的最大值
题目:在一个m×n的棋盘的每一格都放有一个礼物,每个礼物都有一定的价值(价值大于0)。你可以从棋盘的左上角开始拿格子里的礼物,并每次向左或者向下移动一格直到到达棋盘的右下角。给定一个棋盘及其上面的礼物,请计算你最多能拿到多少价值的礼物?
#include<iostream>
#include<string>
#include<vector>
#include <stack>
#include <queue>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unordered_map>
#include <algorithm>
using namespace std;
int getMaxValue_solution1(const int* value, int rows, int cols){
vector<vector<int>> dp(rows, vector<int>(cols, 0));
if(rows >= 1 && cols >= 1){
dp[0][0] = value[0];
} else
return 0;
for(int i = 0; i < rows; ++i){
for(int j = 0; j < cols; ++j){
if(i - 1 >= 0 && j - 1 >= 0)
dp[i][j] = max(value[i * cols + j] + dp[i - 1][j], value[i * cols + j] + dp[i][j - 1]);
else if(i - 1 >= 0 && j - 1 < 0)
dp[i][j] = value[i * cols + j] + dp[i - 1][j];
else if(i - 1 < 0 && j - 1 >= 0)
dp[i][j] = value[i * cols + j] + dp[i][j - 1];
else
dp[i][j] = dp[i][j];
}
}
return dp[rows - 1][cols - 1];
}
int getMaxValue_solution2(const int* value, int rows, int cols){
vector<int> dp(cols, 0);
if(rows >= 1 && cols >= 1){
dp[0] = value[0];
} else
return 0;
for(int i = 0; i < rows; ++i){
for(int j = 0; j < cols; ++j){
if(i - 1 >= 0 && j - 1 >= 0)
dp[j] = max(value[i * cols + j] + dp[j], value[i * cols + j] + dp[j - 1]);
else if(i - 1 >= 0 && j - 1 < 0)
dp[j] = value[i * cols + j] + dp[j];
else if(i - 1 < 0 && j - 1 >= 0)
dp[j] = value[i * cols + j] + dp[j - 1];
else
dp[j] = dp[j];
}
}
return dp[cols - 1];
}
// ====================测试代码====================
void test(const char* testName, const int* values, int rows, int cols, int expected)
{
if(getMaxValue_solution1(values, rows, cols) == expected)
std::cout << testName << ": solution1 passed." << std::endl;
else
std::cout << testName << ": solution1 FAILED." << std::endl;
if(getMaxValue_solution2(values, rows, cols) == expected)
std::cout << testName << ": solution2 passed." << std::endl;
else
std::cout << testName << ": solution2 FAILED." << std::endl;
}
void test1()
{
// 三行三列
int values[][3] = {
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 }
};
int expected = 29;
test("test1", (const int*) values, 3, 3, expected);
}
void test2()
{
//四行四列
int values[][4] = {
{ 1, 10, 3, 8 },
{ 12, 2, 9, 6 },
{ 5, 7, 4, 11 },
{ 3, 7, 16, 5 }
};
int expected = 53;
test("test2", (const int*) values, 4, 4, expected);
}
void test3()
{
// 一行四列
int values[][4] = {
{ 1, 10, 3, 8 }
};
int expected = 22;
test("test3", (const int*) values, 1, 4, expected);
}
void test4()
{
int values[4][1] = {
{ 1 },
{ 12 },
{ 5 },
{ 3 }
};
int expected = 21;
test("test4", (const int*) values, 4, 1, expected);
}
void test5()
{
// 一行一列
int values[][1] = {
{ 3 }
};
int expected = 3;
test("test5", (const int*) values, 1, 1, expected);
}
void test6()
{
// 空指针
int expected = 0;
test("test6", nullptr, 0, 0, expected);
}
int main(int argc, char* argv[])
{
test1();
test2();
test3();
test4();
test5();
return 0;
}
6、打印1到最大的n位数
面试题17
题目:输入数字n,按顺序打印出从1最大的n位十进制数。比如输入3,则打印出1、2、3一直到最大的3位数即999。
#include <cstdio>
#include <memory>
#include <memory.h>
void PrintNumber(char* number);
bool Increment(char* number);
void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index);
// ====================方法一====================
void Print1ToMaxOfNDigits_1(int n)
{
if (n <= 0)
return;
char *number = new char[n + 1];
memset(number, '0', n);
number[n] = '\0';
while (!Increment(number))
{
PrintNumber(number);
}
delete[]number;
}
// 字符串number表示一个数字,在 number上增加1
// 如果做加法溢出,则返回true;否则为false
bool Increment(char* number)
{
bool isOverflow = false;
int nTakeOver = 0;
int nLength = strlen(number);
for (int i = nLength - 1; i >= 0; i--)
{
int nSum = number[i] - '0' + nTakeOver;
if (i == nLength - 1)
nSum++;
if (nSum >= 10)
{
if (i == 0)
isOverflow = true;
else
{
nSum -= 10;
nTakeOver = 1;
number[i] = '0' + nSum;
}
}
else
{
number[i] = '0' + nSum;
break;
}
}
return isOverflow;
}
// ====================方法二====================
void Print1ToMaxOfNDigits_2(int n)
{
if (n <= 0)
return;
char* number = new char[n + 1];
number[n] = '\0';
for (int i = 0; i < 10; ++i)
{
number[0] = i + '0';
Print1ToMaxOfNDigitsRecursively(number, n, 0);
}
delete[] number;
}
void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)
{
if (index == length - 1)
{
PrintNumber(number);
return;
}
for (int i = 0; i < 10; ++i)
{
number[index + 1] = i + '0';
Print1ToMaxOfNDigitsRecursively(number, length, index + 1);
}
}
// ====================公共函数====================
// 字符串number表示一个数字,数字有若干个0开头
// 打印出这个数字,并忽略开头的0
void PrintNumber(char* number)
{
bool isBeginning0 = true;
int nLength = strlen(number);
for (int i = 0; i < nLength; ++i)
{
if (isBeginning0 && number[i] != '0')
isBeginning0 = false;
if (!isBeginning0)
{
printf("%c", number[i]);
}
}
printf("\t");
}
// ====================测试代码====================
void Test(int n)
{
printf("Test for %d begins:\n", n);
Print1ToMaxOfNDigits_1(n);
Print1ToMaxOfNDigits_2(n);
printf("\nTest for %d ends.\n", n);
}
int main(int argc, char* argv[])
{
Test(1);
Test(2);
Test(3);
Test(0);
Test(-1);
return 0;
}
7、把数字翻译成字符串
面试题46:
题目:给定一个数字,我们按照如下规则把它翻译为字符串:0翻译成"a",1翻译成"b",……,11翻译成"l",……,25翻译成"z"。一个数字可能有多个翻译。例如12258有5种不同的翻译,它们分别是"bccfi"、"bwfi"、"bczi"、"mcfi"和 "mzi"。请编程实现一个函数用来计算一个数字有多少种不同的翻译方法。
#include <string>
#include <iostream>
using namespace std;
int GetTranslationCount(const string& number);
int GetTranslationCount(int number)
{
if(number < 0)
return 0;
string numberInString = to_string(number);
return GetTranslationCount(numberInString);
}
int GetTranslationCount(const string& number)
{
int length = number.length();
int* counts = new int[length];
int count = 0;
for(int i = length - 1; i >= 0; --i)
{
count = 0;
if(i < length - 1)
count = counts[i + 1];
else
count = 1;
if(i < length - 1)
{
int digit1 = number[i] - '0';
int digit2 = number[i + 1] - '0';
int converted = digit1 * 10 + digit2;
if(converted >= 10 && converted <= 25)
{
if(i < length - 2)
count += counts[i + 2];
else
count += 1;
}
}
counts[i] = count;
}
count = counts[0];
delete[] counts;
return count;
}
// ====================测试代码====================
void Test(const string& testName, int number, int expected)
{
if(GetTranslationCount(number) == expected)
cout << testName << " passed." << endl;
else
cout << testName << " FAILED." << endl;
}
void Test1()
{
int number = 0;
int expected = 1;
Test("Test1", number, expected);
}
void Test2()
{
int number = 10;
int expected = 2;
Test("Test2", number, expected);
}
void Test3()
{
int number = 125;
int expected = 3;
Test("Test3", number, expected);
}
void Test4()
{
int number = 126;
int expected = 2;
Test("Test4", number, expected);
}
void Test5()
{
int number = 426;
int expected = 1;
Test("Test5", number, expected);
}
void Test6()
{
int number = 100;
int expected = 2;
Test("Test6", number, expected);
}
void Test7()
{
int number = 101;
int expected = 2;
Test("Test7", number, expected);
}
void Test8()
{
int number = 12258;
int expected = 5;
Test("Test8", number, expected);
}
void Test9()
{
int number = -100;
int expected = 0;
Test("Test9", number, expected);
}
int main(int argc, char* argv[])
{
Test1();
Test2();
Test3();
Test4();
Test5();
Test6();
Test7();
Test8();
Test9();
return 0;
}