class Solution {
public boolean isAnagram ( String s, String t) {
int sLen = s. length ( ) ;
int tLen = t. length ( ) ;
if ( sLen != tLen) return false ;
int [ ] sArray = new int [ 26 ] , tArray = new int [ 26 ] ;
for ( int i = 0 ; i < sLen; i++ ) {
sArray[ s. charAt ( i) - 'a' ] ++ ;
tArray[ t. charAt ( i) - 'a' ] ++ ;
}
return Arrays . equals ( sArray, tArray) ;
}
}
class Solution {
public boolean checkInclusion ( String s1, String s2) {
int s1Len = s1. length ( ) ;
int s2Len = s2. length ( ) ;
if ( s1Len > s2Len) return false ;
int [ ] s1Array = new int [ 26 ] ;
int [ ] s2Array = new int [ 26 ] ;
for ( int i = 0 ; i < s1Len; i++ ) {
s1Array[ s1. charAt ( i) - 'a' ] ++ ;
s2Array[ s2. charAt ( i) - 'a' ] ++ ;
}
int left = 0 , right = s1Len - 1 ;
while ( right < s2Len) {
if ( Arrays . equals ( s1Array, s2Array) ) return true ;
right++ ;
if ( right != s2Len) {
s2Array[ s2. charAt ( right) - 'a' ] ++ ;
}
s2Array[ s2. charAt ( left) - 'a' ] -- ;
left++ ;
}
return false ;
}
}
class Solution {
public List < Integer > findAnagrams ( String s, String p) {
List < Integer > res = new ArrayList < > ( ) ;
int sLen = s. length ( ) ;
int pLen = p. length ( ) ;
if ( pLen > sLen) return res;
int [ ] sArray = new int [ 26 ] , pArray = new int [ 26 ] ;
for ( int i = 0 ; i < pLen; i++ ) {
sArray[ s. charAt ( i) - 'a' ] ++ ;
pArray[ p. charAt ( i) - 'a' ] ++ ;
}
int left = 0 , right = pLen - 1 ;
while ( right < sLen) {
if ( Arrays . equals ( pArray, sArray) ) {
res. add ( left) ;
}
right++ ;
if ( right != sLen) {
sArray[ s. charAt ( right) - 'a' ] ++ ;
}
sArray[ s. charAt ( left) - 'a' ] -- ;
left++ ;
}
return res;
}
}
class Solution {
public List < Integer > findDisappearedNumbers ( int [ ] nums) {
var res = new ArrayList < Integer > ( ) ;
boolean [ ] hasNum = new boolean [ nums. length + 1 ] ;
for ( int num : nums) {
hasNum[ num] = true ;
}
for ( int i = 1 ; i <= nums. length; i++ ) {
if ( ! hasNum[ i] ) res. add ( i) ;
}
return res;
}
}
class Solution {
public int hammingDistance ( int x, int y) {
return bitCount ( x ^ y) ;
}
private int bitCount ( int i) {
int count = 0 ;
while ( i > 0 ) {
if ( i % 2 == 1 ) {
count++ ;
}
i >>= 1 ;
}
return count;
}
}
class Solution {
Map < String , Integer > memo = new HashMap < > ( ) ;
public int findTargetSumWays ( int [ ] nums, int target) {
if ( nums. length == 0 ) return 0 ;
return backtrace ( nums, 0 , target) ;
}
private int backtrace ( int [ ] nums, int idx, int target) {
if ( idx == nums. length) {
return target == 0 ? 1 : 0 ;
}
String key = idx + "," + target;
if ( memo. containsKey ( key) ) {
return memo. get ( key) ;
}
int result = backtrace ( nums, idx + 1 , target - nums[ idx] ) + backtrace ( nums, idx + 1 , target + nums[ idx] ) ;
memo. put ( key, result) ;
return result;
}
}
class Solution {
int sum = 0 ;
public TreeNode convertBST ( TreeNode root) {
if ( root == null ) return null ;
convertBST ( root. right) ;
root. val += sum;
sum = root. val;
convertBST ( root. left) ;
return root;
}
}
class Solution {
int max = Integer . MIN_VALUE;
public int diameterOfBinaryTree ( TreeNode root) {
depth ( root) ;
return max;
}
public int depth ( TreeNode root) {
if ( root == null ) return 0 ;
int leftDepth = depth ( root. left) ;
int rightDepth = depth ( root. right) ;
max = Math . max ( max, leftDepth + rightDepth) ;
return Math . max ( leftDepth, rightDepth) + 1 ;
}
}
class Solution {
public int subarraySum ( int [ ] nums, int k) {
if ( nums == null || nums. length == 0 ) return 0 ;
Map < Integer , Integer > map = new HashMap < > ( ) ;
map. put ( 0 , 1 ) ;
int count = 0 ;
int prefixSum = 0 ;
for ( int num : nums) {
prefixSum += num;
int diff = prefixSum - k;
count += map. getOrDefault ( diff, 0 ) ;
map. put ( prefixSum, map. getOrDefault ( prefixSum, 0 ) + 1 ) ;
}
return count;
}
}
class Solution {
public int findUnsortedSubarray ( int [ ] nums) {
if ( nums == null || nums. length == 0 ) return 0 ;
int [ ] newArray = Arrays . copyOf ( nums, nums. length) ;
Arrays . sort ( newArray) ;
int start = 0 ;
int end = nums. length - 1 ;
while ( start < end) {
if ( nums[ start] == newArray[ start] ) {
start++ ;
} else if ( nums[ end] == newArray[ end] ) {
end-- ;
} else {
return end - start + 1 ;
}
}
return 0 ;
}
}
class Solution {
public TreeNode mergeTrees ( TreeNode root1, TreeNode root2) {
if ( root1 == null && root2 == null ) return null ;
if ( root1 == null ) return root2;
if ( root2 == null ) return root1;
TreeNode root = new TreeNode ( root1. val + root2. val) ;
root. left = mergeTrees ( root1. left, root2. left) ;
root. right = mergeTrees ( root1. right, root2. right) ;
return root;
}
}
暂时不写
class Solution {
public int countSubstrings ( String s) {
if ( s == null || s. length ( ) == 0 ) return 0 ;
int len = s. length ( ) ;
boolean [ ] [ ] dp = new boolean [ len] [ len] ;
int count = 0 ;
for ( int i = len - 1 ; i >= 0 ; i-- ) {
for ( int j = i; j < len; j++ ) {
if ( s. charAt ( i) != s. charAt ( j) ) continue ;
dp[ i] [ j] = j - i <= 2 || dp[ i + 1 ] [ j - 1 ] ;
if ( dp[ i] [ j] ) count++ ;
}
}
return count;
}
}
public int [ ] dailyTemperatures ( int [ ] temperatures) {
if ( temperatures == null || temperatures. length == 0 ) return new int [ ] { } ;
int [ ] answer = new int [ temperatures. length] ;
Stack < Integer > idxStack = new Stack < Integer > ( ) ;
for ( int i = 0 ; i < temperatures. length; i++ ) {
while ( ! idxStack. isEmpty ( ) && temperatures[ i] > temperatures[ idxStack. peek ( ) ] ) {
answer[ idxStack. peek ( ) ] = i - idxStack. pop ( ) ;
}
idxStack. push ( i) ;
}
return answer;
}