.

Author: hqztrue

0101-0200/127. Word Ladder 16ms.cpp

@@ -0,0 +1,76 @@
+typedef unsigned int uint;
+const int N=5005,L0=10,L=N*L0; const uint mul=131;
+int vis[N],q[N],v1; uint hsh[N],mul1[L0];
+vector<int> v[L];
+namespace Hash{
+	const uint S=16,S1=32-S,M=1996090921;
+	struct node{
+		int x,t;
+		vector<int> *y;
+	}h[(1<<S)+1005];
+	int T=1;
+	inline void insert(int x,int y){
+		node *p=h+((uint)x*M>>S1);
+		for (;p->t==T;++p)
+			if (p->x==x){p->y->push_back(y); return;}
+		p->t=T; p->x=x; p->y=v+(v1++); p->y->push_back(y);
+	}
+	inline vector<int>** find(int x){
+		for (node *p=h+((uint)x*M>>S1);p->t==T;++p)
+			if (p->x==x)return &p->y;
+		return 0;
+	}
+} using namespace Hash;
+
+class Solution {
+public:
+	int ladderLength(string beginWord, string endWord, vector<string>& w) {
+		for (int i=0;i<v1;++i)v[i].clear();
+		int n=w.size(); v1=0; ++T;
+		for (int i=0;i<n-1;++i)
+			if (w[i]==endWord)swap(w[i],w[n-1]);
+		if (w[n-1]!=endWord)return 0;
+		w.push_back(beginWord); ++n;
+		mul1[0]=1; for (int i=1;i<L0;++i)mul1[i]=mul1[i-1]*mul;
+		for (int i=0;i<n;++i){
+			int l=w[i].size(); uint h0=0;
+			for (char *p=&w[i][0],*end=p+l;p!=end;++p)h0=h0*mul+*p;
+			for (char *p=&w[i][0],*end=p+l;p!=end;++p){
+				uint h1=h0-*p*mul1[end-1-p];
+				insert(h1,i);
+			}
+			hsh[i]=h0;
+		}
+		for (int i=0;i<n;++i)vis[i]=0; vis[n-1]=1;
+		int l=0,r=1,ans=1; q[0]=n-1;
+		while (l<r){
+			int r1=r; ++ans;
+			for (;l<r;++l){
+				int i=q[l]; uint h0=hsh[i];
+				for (char *p=&w[i][0],*end=p+w[i].size();p!=end;++p){
+					uint h1=h0-*p*mul1[end-1-p];
+					vector<int>** pt=find(h1);
+					if (*pt){
+						vector<int> &vec=*(*pt);
+						for (int j:vec)
+							if (!vis[j]){
+								q[r1++]=j,vis[j]=1;
+								if (j==n-2)return ans;
+							}
+						*pt=0;
+					}
+				}
+			}
+			l=r; r=r1;
+		}
+		return 0;
+	}
+};
+
+//IO
+int _IO=[](){
+	ios::sync_with_stdio(0);
+	cin.tie(0); //cout.tie(0);
+	return 0;
+}();
+

0101-0200/127. Word Ladder.pdf

@@ -0,0 +1,49 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+namespace Hash{
+	typedef unsigned int uint;
+	const uint S=14,S1=32-S,M=1996090921;
+	struct node{
+		uint x; int y,t;
+	}h[(1<<S)+1005];
+	int T=1;
+	inline bool insert(uint x){
+		node *p=h+((uint)x*M>>S1);
+		for (;p->t==T;++p)
+			if (p->x==x)return ++p->y==2?1:0;
+		p->t=T; p->x=x; p->y=1; return 0;
+	}
+} using namespace Hash;
+const int M1=1732479145,M2=2012582971,M3=1713253213;
+vector<TreeNode*> ans;
+uint dfs(TreeNode *x){
+	if (!x)return 0;
+	uint l=dfs(x->left),r=dfs(x->right),h=(l*M1+r*M2+x->val)^M3;
+	if (insert(h))ans.push_back(x);
+	return h;
+}
+class Solution {
+public:
+	vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
+		++T; ans.clear();
+		dfs(root);
+		return ans;
+	}
+};
+
+//IO
+int _IO=[](){
+	ios::sync_with_stdio(0);
+	cin.tie(0); //cout.tie(0);
+	return 0;
+}();
+

0101-0200/127. Word Ladder.txt

@@ -1,7 +1,7 @@
 const int N=1005,L=30,CH=26,mul=131;
 namespace Hash{
 	typedef unsigned int uint;
-	const uint S=10,S1=32-S,M=1996090921;
+	const uint S=12,S1=32-S,M=1996090921;
 	struct node{
 		int x,t;
 	}h[(1<<S)+1005];
@@ -43,6 +43,7 @@ class Solution {
 				}
 			}
 			if (i%4==0)m*=mul;
+			if (ans->size()<i)break;
 		}
 		return *ans;
 	}

0601-0700/652. Find Duplicate Subtrees 8ms.cpp

@@ -0,0 +1,49 @@
+const int L=3205,CH=26;
+struct node{
+	node **son;
+	bool flag;
+};
+node _P[L],*p,*_Q[L*CH],**q,*root,**chg[L]; string ans,cur; int c1;
+vector<node*> chg_flag;
+inline node *newnode(){p->son=q; q+=CH; return p++;}
+inline void insert(char *s,int l){
+	node *x=root;
+	for (int i=0;i<l;++i){
+		char c=s[i]-'a';
+		if (!x->son[c]){
+			x->son[c]=newnode();
+			chg[c1++]=x->son+c;
+		}
+		x=x->son[c];
+	}
+	x->flag=1; chg_flag.push_back(x);
+}
+void dfs(node *x){
+	if (!x->flag)return;
+	if (cur.size()>ans.size()||cur.size()==ans.size()&&cur<ans)ans=cur;
+	for (int i=0;i<CH;++i)
+		if (x->son[i]){
+			cur.push_back(i+'a');
+			dfs(x->son[i]);
+			cur.pop_back();
+		}
+}
+class Solution {
+public:
+	string longestWord(vector<string>& w) {
+		p=_P; q=_Q; root=newnode(); root->flag=1; ans=""; c1=0; chg_flag.clear();
+		for (int i=0;i<w.size();++i)insert(&w[i][0],w[i].size());
+		cur=""; dfs(root);
+		for (int i=0;i<c1;++i)*chg[i]=0;
+		for (int i=0;i<chg_flag.size();++i)chg_flag[i]->flag=0;
+		return ans;
+	}
+};
+
+//IO
+int _IO=[](){
+	ios::sync_with_stdio(0);
+	cin.tie(0); //cout.tie(0);
+	return 0;
+}();
+

0601-0700/652. Find Duplicate Subtrees.pdf

@@ -0,0 +1,3 @@
+Let n denote the number of strings.
+1. Enumerate each pair of strings, and use LCP to detect whether they are similar in O(1) time. O(n^2+L).
+

0601-0700/652. Find Duplicate Subtrees.txt

@@ -60,7 +60,7 @@ class Solution {
 };
 
 struct Serializer{
-	string serialize(const vector<TreeNode*> &v){return "";}
+	static string serialize(const vector<TreeNode*> &v){return "";}
 }ser;
 #define _ser_ ser  //LC-US
 #define __Serializer__ Serializer  //LC-CN

0701-0800/720. Longest Word in Dictionary 12ms.cpp

@@ -0,0 +1,38 @@
+const int N=50005,W=32;
+int a[N*W],ans;
+namespace Hash{
+	typedef unsigned int uint;
+	const uint S=19,S1=32-S,M=1996090921;
+	struct node{
+		int x,t;
+	}h[(1<<S)+1005];
+	int T=1;
+	inline void insert(int x){
+		node *p=h+((uint)x*M>>S1);
+		for (;p->t==T;++p)
+			if (p->x==x)return;
+		p->t=T; p->x=x; ++ans;
+	}
+} using namespace Hash;
+class Solution {
+public:
+	int subarrayBitwiseORs(vector<int>& v) {
+		int l=0,r=0,a1=0; ans=0; ++T;
+		for (int x:v){
+			r=a1; a[a1++]=x;
+			for (int i=l;i<r;++i)
+				if (a[a1-1]!=(a[i]|x))a[a1++]=a[i]|x;
+			l=r;
+		}
+		for (int i=0;i<a1;++i)insert(a[i]);
+		return ans;
+	}
+};
+
+//IO
+int _IO=[](){
+	ios::sync_with_stdio(0);
+	cin.tie(0); //cout.tie(0);
+	return 0;
+}();
+

0701-0800/720. Longest Word in Dictionary 12ms_trie.cpp

@@ -1,2 +1,3 @@
 This problem is a variant of subset sum, and is NPC.
+DP or dfs.
 

0701-0800/720. Longest Word in Dictionary.pdf

@@ -0,0 +1,2 @@
+first use dfs to find the map, then bfs. O(nm).
+

0801-0900/839. Similar String Groups.txt

@@ -0,0 +1,2 @@
+O(n).
+

0801-0900/894. All Possible Full Binary Trees 28ms_hack.cpp

@@ -0,0 +1,2 @@
+O(log n).
+

0801-0900/898. Bitwise ORs of Subarrays 52ms.cpp

@@ -0,0 +1,2 @@
+Sort the queries in O(m+q) time using radix sort. For each edge, compute cnt in O(1) time. Then we only need to consider pairs of vertices that are not adjacent. We can either use FFT (independent from the number of queries), or use 2SUM for each query in O(n) time. O(min{m log m,qn}+n+m+q).
+

0801-0900/898. Bitwise ORs of Subarrays.pdf

@@ -0,0 +1,2 @@
+O(n).
+

0801-0900/898. Bitwise ORs of Subarrays.txt

@@ -0,0 +1,2 @@
+O(n).
+

1301-1400/1334. Find the City With the Smallest Number of Neighbors at a Threshold Distance.pdf

@@ -0,0 +1,2 @@
+First use undirected weighted SSSP to compute distanceToLastNode(*) in O(n+m) time \cite{thorup1999undirected}, then DP on a DAG. O(n+m).
+

1701-1800/1774. Closest Dessert Cost.txt

@@ -18,6 +18,7 @@ Problem ID marked with leading ~ indicates there's good evidences that the algor
 ~762 Prime Number of Set Bits in Binary Representation  
 787 Cheapest Flights Within K Stops  
 837 New 21 Game  
+839 Similar String Groups  
 ~898 Bitwise ORs of Subarrays  
 1057 Campus Bikes  
 ~1074 Number of Submatrices That Sum to Target