Q17.21 直方图的水量
给定一个直方图(也称柱状图)，假设有人从上面源源不断地倒水，最后直方图能存多少水量?直方图的宽度为 1。
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的直方图，在这种情况下，可以接 6 个单位的水（蓝色部分表示水）。 感谢 Marcos 贡献此图。
示例:
输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/volume-of-histogram-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
双指针
class Solution {
public int trap(int[] height) {
int res=0;
int l=0;
int r=height.length-1;
int temp=0;
while(l<r){
if(height[l]<=height[r]){
temp=Math.max(temp,height[l]);
res+=temp-height[l++];
}else {
temp=Math.max(temp,height[r]);
res+=temp-height[r--];
}
}
return res;
}
}Q17.22 单词转换
给定字典中的两个词，长度相等。写一个方法，把一个词转换成另一个词， 但是一次只能改变一个字符。每一步得到的新词都必须能在字典中找到。
编写一个程序，返回一个可能的转换序列。如有多个可能的转换序列，你可以返回任何一个。
示例 1:
输入:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]输出:
["hit","hot","dot","lot","log","cog"]
示例 2:输入:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]输出: []
解释: endWord "cog" 不在字典中，所以不存在符合要求的转换序列。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-transformer-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {
public List<String> findLadders(String beginWord, String endWord, List<String> wordList) {
if (!wordList.contains(endWord)) {
return new ArrayList<>();
}
return dfs(beginWord, endWord, wordList, new HashSet<>());
}
private LinkedList<String> dfs(String beginWord, String endWord, List<String> wordList, Set<String> visited) {
if (beginWord.equals(endWord)) {
LinkedList<String> collector = new LinkedList<>();
collector.addFirst(beginWord);
return collector;
}
visited.add(beginWord);
for (String s : wordList) {
if (visited.contains(s)) continue;
if (check(beginWord, s)) {
LinkedList<String> sub = dfs(s, endWord, wordList, visited);
if (!sub.isEmpty()) {
sub.addFirst(beginWord);
return sub;
}
}
}
return new LinkedList<>();
}
private boolean check(String w1, String w2) {
if (w1.length() != w2.length()) return false;
int n = w1.length();
int diff = 0;
for (int i = 0; i < n; i++) {
if (w1.charAt(i) != w2.charAt(i) && ++diff > 1) {
return false;
}
}
return true;
}
}Q17.23 最大黑方阵
给定一个方阵，其中每个单元(像素)非黑即白。设计一个算法，找出 4 条边皆为黑色像素的最大子方阵。
返回一个数组 [r, c, size] ，其中 r, c 分别代表子方阵左上角的行号和列号，size 是子方阵的边长。若有多个满足条件的子方阵，返回 r 最小的，若 r 相同，返回 c 最小的子方阵。若无满足条件的子方阵，返回空数组。
示例 1:
输入:
[
[1,0,1],
[0,0,1],
[0,0,1]
]
输出: [1,0,2]
解释: 输入中 0 代表黑色，1 代表白色，标粗的元素即为满足条件的最大子方阵
示例 2:输入:
[
[0,1,1],
[1,0,1],
[1,1,0]
]
输出: [0,0,1]
提示：matrix.length == matrix[0].length <= 200
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-black-square-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {
public int[] findSquare(int[][] matrix) {
int[] res=new int[3];
int m=matrix.length;
if(m==0) return res;
int[][][] dp=new int[m+1][m+1][2];
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) {
if (matrix[i-1][j-1] == 0){
dp[i][j][0] = 1 + dp[i][j-1][0];
dp[i][j][1] = 1 + dp[i-1][j][1];
}
}
}
int l = 0;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) {
for (int side = Math.min(dp[i][j][0], dp[i][j][1]); side >= 1; side--){
if (dp[i][j-side+1][1] >= side && dp[i-side+1][j][0] >= side){
if(side>l){
l = side;
res[0]=i-side;
res[1]=j-side;
res[2]=side;
break;
}
}
}
}
}
return res[2]==0?new int[0]:res;
}
}Q17.24 最大子矩阵
给定一个正整数、负整数和 0 组成的 N × M 矩阵，编写代码找出元素总和最大的子矩阵。
返回一个数组 [r1, c1, r2, c2]，其中 r1, c1 分别代表子矩阵左上角的行号和列号，r2, c2 分别代表右下角的行号和列号。若有多个满足条件的子矩阵，返回任意一个均可。
注意：本题相对书上原题稍作改动
示例：
输入：
[
[-1,0],
[0,-1]
]
输出：[0,1,0,1]
解释：输入中标粗的元素即为输出所表示的矩阵
说明：
1 <= matrix.length, matrix[0].length <= 200
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-submatrix-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
public int[] getMaxMatrix(int[][] matrix) {
int m=matrix.length;
int n=matrix[0].length;
int[] res=new int[4];
int maxSum=Integer.MIN_VALUE;
int r1=0,r2=0;//行范围
int c1=0,c2=0;//列范围
//把二维数组看成一维数组，每列和构成新数组
for(r1=0; r1<m; r1++){
int[] dp = new int[n];//每列和 dp[i]-第i列在r1到r2之间的元素和
for(r2=r1; r2<m; r2++){
//对任意两行之间的元素
int sum=0;
//遍历列
for(int c=0; c<n; c++){
dp[c]+=matrix[r2][c];
//类似一维数组求最大子数组和
if(sum>0) {
sum+=dp[c];
c1=c1;
c2=c2+1;
}
else {
sum=dp[c];
c1=c;
c2=c;
}
if(sum>maxSum){//更新坐标
maxSum=sum;
res[0]=r1;
res[1]=c1;
res[2]=r2;
res[3]=c2;
}
}
}
}
return res;
}Q17.25 单词矩阵
给定一份单词的清单，设计一个算法，创建由字母组成的面积最大的矩形，其中每一行组成一个单词(自左向右)，每一列也组成一个单词(自上而下)。不要求这些单词在清单里连续出现，但要求所有行等长，所有列等高。
如果有多个面积最大的矩形，输出任意一个均可。一个单词可以重复使用。
示例 1:
输入: ["this", "real", "hard", "trh", "hea", "iar", "sld"]
输出:
[
"this",
"real",
"hard"
]
示例 2:输入: ["aa"]
输出: ["aa","aa"]
说明：words.length <= 1000
words[i].length <= 100
数据保证单词足够随机来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-rectangle-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class TreeNode{
boolean isWord;
TreeNode[] next;
public TreeNode(){
this.isWord = false;
this.next = new TreeNode[26];
}
}
class Trie{
private TreeNode root;
Trie(){
this.root = new TreeNode();
}
public void insert(String word){
TreeNode curr = root;
for(int i=0;i<word.length();i++){
int index = word.charAt(i)-'a';
if(curr.next[index]==null){
curr.next[index] = new TreeNode();
}
curr = curr.next[index];
}
curr.isWord = true;
}
}
Trie tree;
List<String> res;
TreeNode root;
int max;
int maxArea;
public String[] maxRectangle(String[] words) {
HashMap<Integer,Set<String>> map = new HashMap<>();
this.tree = new Trie();
this.res = new ArrayList<>();
this.root = tree.root;
this.max = 0;
for(String word:words){
Set<String> temp = map.getOrDefault(word.length(), new HashSet<>());
temp.add(word);
max = Math.max(max,word.length());
map.put(word.length(),temp);
tree.insert(word);
}
this.maxArea = 0;//需要记录当前是否是最大
for(int len:map.keySet()){
dfs(map.get(len),new ArrayList<>(),len);
}
return res.toArray(new String[res.size()]);
}
private void dfs(Set<String> set,ArrayList<String> temp,int len){
if(len*max<maxArea) return;//如果当前长度*最大的字符长度面积仍然小，那么就不用回溯了
if(temp.size()>max) return ;
for(String str:set){
temp.add(str);
boolean[] res = isVaild(temp);
if(res[0]){
int area = temp.size()*len;
if(res[1]&&area>maxArea){
maxArea = area;
this.res = new ArrayList<>(temp);
}
dfs(set, temp, len);
}
temp.remove(temp.size()-1);
}
}
private boolean[] isVaild(List<String> temp){
boolean [] res = new boolean[2];//2个状态位记录：
boolean flag = true;
//第一个位置记录当前列是否有包含不在字典树的单词，否为true;
//第二个位置当前是否构成全部的单词 是为true;
int len = temp.size();
int n = temp.get(0).length();
for(int i=0;i<n;i++){
TreeNode curr = root;
for (int j = 0; j < len; j++) {
int index = temp.get(j).charAt(i)-'a';
if(curr.next[index]==null) return res;
curr = curr.next[index];
}
if(curr.isWord==false) flag = false;
}
res[0] = true;
res[1] = flag;
return res;
}Q17.26 稀疏相似度
两个(具有不同单词的)文档的交集(intersection)中元素的个数除以并集(union)中元素的个数，就是这两个文档的相似度。例如，{1, 5, 3} 和 {1, 7, 2, 3} 的相似度是 0.4，其中，交集的元素有 2 个，并集的元素有 5 个。给定一系列的长篇文档，每个文档元素各不相同，并与一个 ID 相关联。它们的相似度非常“稀疏”，也就是说任选 2 个文档，相似度都很接近 0。请设计一个算法返回每对文档的 ID 及其相似度。只需输出相似度大于 0 的组合。请忽略空文档。为简单起见，可以假定每个文档由一个含有不同整数的数组表示。
输入为一个二维数组 docs，docs[i] 表示 id 为 i 的文档。返回一个数组，其中每个元素是一个字符串，代表每对相似度大于 0 的文档，其格式为 {id1},{id2}: {similarity}，其中 id1 为两个文档中较小的 id，similarity 为相似度，精确到小数点后 4 位。以任意顺序返回数组均可。
示例:
输入:
[
[14, 15, 100, 9, 3],
[32, 1, 9, 3, 5],
[15, 29, 2, 6, 8, 7],
[7, 10]
]
输出:
[
"0,1: 0.2500",
"0,2: 0.1000",
"2,3: 0.1429"
]
提示：docs.length <= 500
docs[i].length <= 500来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sparse-similarity-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
public List<String> computeSimilarities(int[][] docs) {
List<String> res = new ArrayList<>();
Map<Integer, List<Integer>> map = new HashMap<>();
int[][] ans = new int[docs.length][docs.length];
for (int i = 0; i < docs.length; i++) {
for (int j = 0; j < docs[i].length; j++) {
List<Integer> list = map.get(docs[i][j]);
if (list == null) {
list = new ArrayList<>();
map.put(docs[i][j], list);
} else {
for (Integer k : list) {
ans[i][k]++;
}
}
list.add(i);
}
for (int k = 0; k < docs.length; k++) {
if (ans[i][k] > 0) {
res.add(k + "," + i + ": " + String.format("%.4f", (double) ans[i][k] / (docs[i].length + docs[k].length - ans[i][k])));
}
}
}
return res;
}
扫一扫
531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
