题目链接：rank-teams-by-votes/
解法：
这道题就是统计每个队伍在每个排名的投票数，队伍为A、B、C，则排名有1、2、3，按照投票数进行降序排列。如果有队伍在每个排名的投票数都一样，那么按照字母序进行排列。
可以用哈希表也可以用数组处理（因为最多有26个队伍，即26个字母）。
细节在于按照字母序排列，为了统一为按照数字降序排列，可以把队伍（字母）转为 (Z - 队伍)，这样的话，如果队伍是A，那么数字为26，字母为Z，那么数字为0，字母序排列=数字降序排列。
参考题解：1.使用哈希表排序?
边界条件：无
时间复杂度：O(nk+n*nlog?n)，其中 n?是数组 votes中每一个字符串的长度（参与排名的人数），k?是数组 votes 的长度（参与投票的人数）。「遍历统计」的时间复杂度为 O(nk)，「排序」的时间复杂度为 O(nlog?n)，由于需要两两比较，那么再乘以n。
空间复杂度：O(n*n)。哈希映射中键值对的数量为 n，每个值使用 O(n)?的空间。
class Solution {
public:
string rankTeams(vector<string>& votes) {
unordered_map<char, vector<int>> ranking;
// 初始化map，key是字母(队)，value是所有排名的投票数
// 为了最后一个排序规则：按照字母序来排，所以value加了一个元素
for (char v: votes[0]) {
int topn = votes[0].size();
ranking[v].resize(topn+1);
// 如果v是A，那么最后一位是26，如果是Z，那么为0
ranking[v][topn] = 'Z' - v;
}
//遍历统计每个队伍每个排名的票数
for (const string& vote: votes) {
for (int i=0; i<vote.size(); i++) {
ranking[vote[i]][i]++;
}
}
// 复制到可排序的容器中
vector<pair<char, vector<int>>> sortedRanking(ranking.begin(), ranking.end());
// 排序，排名相等的情况下按字母序来排
sort(sortedRanking.begin(), sortedRanking.end(), [](const auto& s1, const auto& s2) {
return s1.second > s2.second;
});
string res;
for (auto& rank: sortedRanking) {
res += rank.first;
}
return res;
}
};题目链接：two-city-scheduling/
解法：
假定2N人都去B市，则费用为 price_B累加：sum_b。现在让其中的N个人不去B市，而是直接去A市。如果其中一个去A市，那么这个费用就变成 sum_b +?(price_A - price_B)。
所有的price_B累加是固定值，要让sum最小，我们只要按(price_A - price_B)排序，这个值小的前N个人去A市，那sum就最小。
参考解法：贪心
边界条件：无
时间复杂度：O(nlogn)，排序。
空间复杂度：O(n)
class Solution {
public:
int twoCitySchedCost(vector<vector<int>>& costs) {
sort(costs.begin(), costs.end(), [] (const vector<int>& c1, const vector<int>& c2) {
return (c1[0] - c1[1]) < (c2[0] - c2[1]);
});
int result = 0;
int n = costs.size() / 2;
for (int i=0; i<n; i++) {
result += costs[i][0] + costs[n+i][1];
};
return result;
}
};题目链接：longest-line-of-consecutive-one-in-matrix
解法：
思路参考：yiduobo的每日leetcode 562.矩阵中最长的连续1线段 - 知乎
动态规划问题。令row[i][j]、col[i][j]、left[i][j]、right[i][j]分别表示以单元格(i, j)为终点的水平方向、竖直方向、左对角线方向、右对角线方向上的连续1的数目，那么对于这四个值，若当前的mat[i][j] = 0，这四个值都都为0，否则：
当j = 0时，row[i][j] = 1，否则row[i][j] = row[i][j -1] + 1
当i = 0时，col[i][j] = 1，否则col[i][j] = col[i - 1][j] + 1
当i = 0或j = 0时，left[i][j] = 0，否则left[i][j] = left[i - 1][j - 1] + 1
当i = 0或j = n - 1时，right[i][j] = 0，否则right[i][j] = left[i - 1][j + 1] + 1
计算完成后，取四个数组中的最大值作为答案即可。
这个题涉及到4个方向，初始化比较麻烦，所以没有初始化，直接从0开始遍历。
具体代码实现参考：动态规划
边界条件：无
时间复杂度：O(mn)
空间复杂度：O(mn)
class Solution {
public:
int longestLine(vector<vector<int>>& mat) {
int m = mat.size();
int n = mat[0].size();
int res = 0;
vector<vector<vector<int>>> dp(4, vector<vector<int>>(m, vector<int>(n, 0)));
for (int i=0; i<m; i++) {
for (int j=0; j<n; j++) {
if (mat[i][j] == 0) continue;
dp[0][i][j] = j==0? 1: 1+dp[0][i][j-1];
dp[1][i][j] = i==0? 1: 1+dp[1][i-1][j];
dp[2][i][j] = (i==0 || j==0)? 1: 1+dp[2][i-1][j-1];
dp[3][i][j] = (i==0 || j==n-1)? 1: 1+dp[3][i-1][j+1];
// 更新结果
for (int k=0; k<4; k++) {
res = max(res, dp[k][i][j]);
}
}
}
return res;
}
};