2019牛客暑期多校訓練營（第三場）----C-Guessing ETT

原創 int *zym； 2020-02-20 17:01

首先發出題目鏈接：
鏈接：https://ac.nowcoder.com/acm/contest/883/C
來源：牛客網
涉及：遞歸、二分查找

點擊這裏回到2019牛客暑期多校訓練營解題—目錄貼

題目如下
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在此之前，先要說明一下歐拉序和棧的關係，首先我們要有一棵任意的樹，如下
在這裏插入圖片描述
如圖所示，每個節點都有一個值，我們從樹的根節點開始先走左子樹，然後走右子樹，走到葉子結點就往回走，把每次走過的節點的上編號按順序寫出來就是歐拉序，如下圖所示：
在這裏插入圖片描述
如上圖所示，對應的歐拉序爲124252131

可以看出，獲得歐拉序是一個遞歸加回溯的過程，那麼就可以認爲是一個入棧加出棧的過程

1.首先根節點1入棧。

2.走到節點2，2入棧。

3.走到節點4，4入棧。

4.節點4是葉子節點，於是往回走，4出棧。

5.返回到節點2，然後走到節點5，5入棧。

6.節點5是葉子節點，於是往回走，5出棧。

7.返回到節點2，節點2的左右子樹都走過，往回走，2出棧。

8.返回到節點1，然後走到節點3，3入棧。

9.節點3是葉子節點，於是往回走，3出棧。

10.返回到節點1，節點1的左右子樹都走過，整棵樹都走過了，1出棧，結束。

入棧認爲是第一次走到了此節點，出棧認爲是離開以此節點爲根節點的樹。

準備工作

瞭解了歐拉序，再看看題目，題目說的是本來有一個歐拉序，但是中間某些值不知道，叫你補全這個歐拉序。

首先我們可以知道，這個歐拉序的第一個值和最後一個值一定是1。

for(int i = 1; i <= 2*n-1; i++){//輸入歐拉序 
	scanf("%d", &num[i]);
}
num[1] = num[2*n-1] = 1;//歐拉序開始和結束一定是1

其次可以明白的是，整個歐拉序代表着一棵樹，原序列中的首字符與尾字符相同的子串，我們可以認爲是一顆子樹，即先進入到這棵子樹，然後從這棵子樹出來。

所以我們需要遞歸每一棵數（即遞歸原串中的每一條首字符與尾字符相同的子串），一步步的解決問題即可

再次之前，我們要記錄原序列中每一個已知元素的位置，用vector數組來存

vector<int> position[maxn];//position[i]表示數字i在歐拉序中出現的位置 

for(int i = 1; i <= 2*n-1; i++){
	if(num[i] != -1)	position[num[i]].push_back(i);//把所有不是-1的數位置提取出來 
}

同時，原序列中肯定出現了一些沒有出現過的值，這些值也提取出來，留到之後用

vector<int> can;//can存1~n中沒有出現過的數 

for(int i = 1; i <= n; i++){
	if(!position[i].size())	can.push_back(i);//把所有沒有使用出現過的數提取出來 
}

做好了一些準備工作，就可以開始遞歸解決每一個滿足條件子串了（當做子問題來處理），先處理根節點爲1的每一棵子樹。那就循環原序列中每兩個距離最近的1

for(int i = 0; i < position[1].size() - 1; i++){
	solve(position[1][i]+1, position[1][i+1]-1, 1);//遞歸解決每一個子問題 （子串） 
}

如下所示
在這裏插入圖片描述
在這裏插入圖片描述

對於每一個子問題（滿足條件的子串），還可以把它分解成更小的子問題（即子問題的子問題），如下圖所示，某一個以1位首尾的子問題中，還有其他更小子問題
在這裏插入圖片描述
但是發現，雖然我們解決了所有的子問題的子問題，但是子問題並沒有被完全解決，如圖可以看出子問題由子問題的子問題和-1來組成的。

所以在解決子問題的時候，可以先解決所有的子問題的子問題，然後用每一個子問題的子問題序列的根節點來代替這整個子問題的子問題，然後用新的vector來存當前的子問題。於是新的當前子問題就沒有更小的子問題了。

上面的圖當所有子問題的子問題全部解決之後就變成了
在這裏插入圖片描述
上圖中最後變換得到的序列用一個vector類型的len變量來存。

同時就算當前子問題的所有更小的子問題被解決之後，此子問題中還存在未知的數（-1），爲了能表示當前-1的位置，我們把這個-1重新賦值爲−1∗i    (i爲此−1在原序列中的位置)-1*i\ \ \ \ (i爲此-1在原序列中的位置)這樣既能表示這個值是未知的，也能表示這個值在原歐拉序中的位置情況。

void solve(int l, int r, int tiny){//l，r表示子序列的左右位置，tiny表示遞歸此部分歐拉遊覽樹的根節點序號 
	if(l > r)	return;
	vector<int> len;//len表示當前子問題中的更小的子問題被解決後的序列
	for(int i = l; i <= r; i++){//遍歷原序列
		if(num[i] == -1){
			len.push_back(-i);//如果位置i的數是-1，用-i來進行標記 
		}
		else{
			len.push_back(num[i]);//如果位置i的數不是-1，說明值已確定，直接放入len中 
			for(int j = 0; j < position[num[i]].size()-1; j++){
				solve(position[num[i]][j]+1, position[num[i]][j+1]-1, num[i]);//繼續遞歸解決所有根節點爲num[i]子問題的子問題（子序列） 
			}
			i = position[num[i]].back();//由於中間一段的子序列已經被解決，所以把i跳到這一段的最後面 
		}
	}
	return;
}

經過上面 solvesolve 函數的處理，len 序列則相當於是一個最小的子問題序列（沒有更小的子問題了），此時需要一個 handhand 函數來處理 len 序列中剩餘的未知的數。

假設hand所處理的一個len序列爲
在這裏插入圖片描述
遍歷此時的 len 序列，開始模擬棧，記得一開始要將 tiny 的值入棧，因爲 len 序列中可能會出現與 tiny 相同的值。

如果遇到一個確定的數（正數）len[i]len[i]，如果棧頂的下一個元素 Stack[Stack.size()−2]Stack[Stack.size()-2] 與此元素相同，則需要把棧頂元素出棧。

if(len[i] > 0){//如果len[i]是已經確定的，則把它入棧 
	if(Stack.size() > 1 && Stack[Stack.size()-2] == len[i]){
	//如果棧頂元素和len[i]相同，則是ETT的出棧過程，所以len[i]不入棧，把棧頂元素出棧即可 
		Stack.pop_back();
	}
	else	Stack.push_back(len[i]);//否則把len[i]入棧 
}

如果遇到一個不確定的數（負數），那麼就要考慮一些情況了：

1.這個數可能與序列後面出現的某個數相同，比如下面這種情況的歐拉序
在這裏插入圖片描述
第二個空（-2那個位置）的數只能填後面出現的4或者2，不能填未曾出現的5，那麼通過觀察發現，如果當前空 len[i]len[i] 要填後面所出現的某個數 len[j]len[j]，我們先將當前的 len 序列寫出另一個序列 x。

如果 len[i]len[i]是一個確定的數，那麼 x[i]=1x[i]=1
否則 x[i]=0x[i]=0

得到 x 序列之後，我們再得到 x 序列的前綴和 sum 序列，sum 序列纔是我們真正用到的，如下
在這裏插入圖片描述
回過頭探討剛剛的問題：如果當前空 len[i]len[i] 要填後面所出現的某個數 len[j]len[j]，那麼需要滿足條件
(sum[j−1]−sum[i])∗2=j−i      [i≡j(mod2)](sum[j-1]-sum[i])*2=j-i\ \ \ \ \ \ [i\equiv j\pmod{2}]
變形得
j−2∗sum[j−1]=i−2∗sum[i]      [i≡j(mod2)]j-2*sum[j-1]=i-2*sum[i]\ \ \ \ \ \ [i\equiv j\pmod{2}]
其中 ii 是已知的，就是當前考慮的 len[i]len[i] 的位置，我們需要找的是序列後面滿足條件的 len[j]len[j]，jj 是未知的，使 len[i]=len[j]len[i]=len[j]

可以先遍歷一次原序列，把所有已知的元素 len[i]len[i] 的 i−len[i−1]i-len[i-1] 按照 ii 的奇偶性分開放在兩個set中，以後每次考慮當前 len[i]len[i] 是否可以與後面某個 len[j]len[j] 相同時，就對於set二分就可以了，用一個變量 pospos 來記錄滿足條件那個值的位置

typedef pair<int, int> P;
static set<P> line[2];//line[1]存len序列下標（i）爲奇數的i-2*sum[i-1]並排序 , line[0]存len序列下標爲偶數的i-2*sum[i-1]並排序 
//p.first表示i-2*sum[i-1]的值,p.second表示i的值

for(int i = 1; i < len.size(); i++){//遍歷len序列 ，把sum序列和兩個set序列確定下來 
	sum[i] = sum[i-1] + (len[i] > 0);//更新sum[i]的值 
	if(len[i] > 0){//如果len[i]的值是確定的（大於0） ，則把i-2*sum[i-1]插入set中 
		line[i&1].insert(P(i-2*sum[i-1], i));//i&1判斷下標是奇數還是偶數 ,i表示位置 
	}
}

int pos = len.size();//先確定len[i]是否能與len序列後面某一個元素相同，pos存那個元素的位置，先初始化爲len.size() 
while(1){//開始尋找 
	auto p = line[i&1].lower_bound(P(i-2*sum[i], 0));
	//需要尋找的那個元素滿足兩個條件，下標奇偶性相同，(sum[pos-1]-sum[i])*2=pos-i ,pos>i
	if(p == line[i&1].end() || (*p).first != i-2*sum[i])	break;//如果找到end()的位置還找不到，說明不存在，break 
	else if((*p).second < i){
	//如果找到的這個元素的位置比len[i]的位置(i)還前面，則刪除這個元素，因爲以後它都用不着 
		line[i&1].erase(p);
	}
	else{
	//滿足條件，則把此元素的位置賦值給pos 
		pos = (*p).second;
		break;
	}
}

當前 len[i]len[i] 成功賦予一個值 len[pos]len[pos] 之後，還要判斷 len 序列在 ii 位置之前有沒有出現過與 len[pos]len[pos] 同樣的值

此時需要用一個 visitvisit 數組來判斷，用一個 timestimes變量來判斷這是第幾次執行 handhand 函數

遍歷 lenlen 序列時，如果 visit[len[i]]!=timesvisit[len[i]] != times，那麼就把 visit[len[i]]visit[len[i]] 的值賦爲 timestimes，後面如果又遍歷到相同的值 len[i]len[i] ，則此時 visit[len[i]]=timesvisit[len[i]] = times，表示 len 序列之前出現過 len[i]len[i]

if(pos < len.size()){//如果找到一個滿足條件的元素 
	num[-len[i]] = len[pos];//那麼原序列的這個未知的值賦值爲len[pos] 
	if(visit[len[pos]] == times){
	//如果visit[len[pos]]等於times，表示在當前的len序列中之前已經出現len[pos]，那就已知出棧知道棧頂爲len[pos]即可 
		while(Stack.back() != len[pos])	Stack.pop_back();
	}
	else{
	//否則把visit[len[pos]]賦值爲times，把len[pos]入棧 
		visit[len[pos]] = times;
		Stack.push_back(len[pos]);
	}
}

2.這個數可能與序列前面出現的某個數相同，最簡單情況就是下面的歐拉序
在這裏插入圖片描述
最後那個-5的位置肯定填的是前面出現過的1，但是很容易發現，如果當前 len[i]len[i] 與 len 序列之前出現過的某個值相同，那麼肯定與棧頂的下一個元素值相同，前提是棧內至少有兩個元素。
（因爲該出棧的都出棧了，上圖中遍歷到-5時棧內情況爲1,3）

else{//如果找不到一個滿足條件的元素 
	if(Stack.size() > 1){//如果棧內有剩餘元素 ，就把原序列的這個未知的值賦值爲棧頂的下一個元素（不能賦值爲棧頂元素） 
		num[-len[i]] = Stack[Stack.size()-2];
		Stack.pop_back();//將棧頂元素出棧，模擬ETT遍歷 
	}
}

3.這個數應該賦值爲原歐拉序中從未出現過的數

所以之前要用一個vector類型的 cancan 變量來存這些數。這種情況發生在第二種情況棧內元素小於2的情況。

所以最後第一種情況沒有發生的代碼爲

else{//如果找不到一個滿足條件的元素 
	if(Stack.size() > 1){//如果棧內有剩餘元素 ，就把原序列的這個未知的值賦值爲棧頂的下一個元素（不能賦值爲棧頂元素） 
		num[-len[i]] = Stack[Stack.size()-2];
		Stack.pop_back();//將棧頂元素出棧，模擬ETT遍歷 
	}
	else{
		num[-len[i]] = can.back();//否則就把原序列的這個未知的值賦值爲一個原序列未曾出現過的新元素 
		Stack.push_back(can.back());//把這個元素入棧，模擬ETT遍歷 
		can.pop_back();//把這個新元素從can中移出，表示這個元素被使用過了 
	}
}

整個 handhand 函數爲

void hand(vector<int> &len, int tiny){
	times ++;//次數加1 
	static vector<int> sum;//sum[i]表示從len[0]到len[1]有多少個不是-1的數 ，類似於前綴和 
	static vector<int> Stack;//Stack模擬歐拉遊覽樹類似出棧入棧的過程 
	static set<P> line[2];//line[1]存len序列下標（i）爲奇數的i-2*sum[i-1]並排序 , line[0]存len序列下標爲偶數的i-2*sum[i-1]並排序 
	Stack.clear();Stack.push_back(tiny);//清空Stack，並把tiny先入棧 
	line[0].clear();line[1].clear();//清空 
	sum.clear();//清空 
	sum.resize(len.size());//sum的大小根據當前考慮的序列len來決定 
	sum[0] = (len[0] > 0);//先求出sum[0]的值，根據len[0]來決定 
	for(int i = 1; i < len.size(); i++){//遍歷len序列 ，把sum序列和兩個set序列確定下來 
		sum[i] = sum[i-1] + (len[i] > 0);//更新sum[i]的值 
		if(len[i] > 0){//如果len[i]的值是確定的（大於0） ，則把i-2*sum[i-1]插入set中 
			line[i&1].insert(P(i-2*sum[i-1], i));//i&1判斷下標是奇數還是偶數 ,i表示位置 
		}
	}
	for(int i = 0; i < len.size(); i++){//遍歷 len序列，把裏面沒有確定的值確定下來 
		if(len[i] > 0){//如果len[i]是已經確定的，則把它入棧 
			if(Stack.size() > 1 && Stack[Stack.size()-2] == len[i]){
			//如果棧頂元素和len[i]相同，則是ETT的出棧過程，所以len[i]不入棧，把棧頂元素出棧即可 
				Stack.pop_back();
			}
			else	Stack.push_back(len[i]);//否則把len[i]入棧 
		}
		else{//如果len[i]沒有被確定 
			int pos = len.size();//先確定len[i]是否能與len序列後面某一個元素相同，pos存那個元素的位置，先初始化爲len.size() 
			while(1){//開始尋找 
				auto p = line[i&1].lower_bound(P(i-2*sum[i], 0));
				//需要尋找的那個元素滿足兩個條件，下標奇偶性相同，(sum[pos-1]-sum[i])*2=pos-i ,pos>i
				if(p == line[i&1].end() || (*p).first != i-2*sum[i])	break;//如果找到end()的位置還找不到，說明不存在，break 
				else if((*p).second < i){
				//如果找到的這個元素的位置比len[i]的位置(i)還前面，則刪除這個元素，因爲以後它都用不着 
					line[i&1].erase(p);
				}
				else{
				//滿足條件，則把此元素的位置賦值給pos 
					pos = (*p).second;
					break;
				}
			}
			if(pos < len.size()){//如果找到一個滿足條件的元素 
				num[-len[i]] = len[pos];//那麼原序列的這個未知的值賦值爲len[pos] 
				if(visit[len[pos]] == times){
				//如果visit[len[pos]]等於times，表示在當前的len序列中之前已經出現len[pos]，棧內肯定存在len[pos]這個值，那就一直出棧知道棧頂爲len[pos]即可 
					while(Stack.back() != len[pos])	Stack.pop_back();
				}
				else{
				//否則把visit[len[pos]]賦值爲times，把len[pos]入棧 
					visit[len[pos]] = times;
					Stack.push_back(len[pos]);
				}
			}
			else{//如果找不到一個滿足條件的元素 
				if(Stack.size() > 1){//如果棧內有剩餘元素 ，就把原序列的這個未知的值賦值爲棧頂的下一個元素（不能賦值爲棧頂元素） 
					num[-len[i]] = Stack[Stack.size()-2];
					Stack.pop_back();//將棧頂元素出棧，模擬ETT遍歷 
				}
				else{
					num[-len[i]] = can.back();//否則就把原序列的這個未知的值賦值爲一個原序列未曾出現過的新元素 
					Stack.push_back(can.back());//把這個元素入棧，模擬ETT遍歷 
					can.pop_back();//把這個新元素從can中移出，表示這個元素被使用過了 
				}
			}
		}
	}
	return;
}

代碼如下：

#include <iostream>
#include <vector>
#include <set>
using namespace std;
typedef pair<int, int> P;
const int maxn = 5e5+5;
int T, num[maxn], n, times = 0;//T表示T組輸入，num存歐拉序的數，n表示1~n的歐拉序，times表示第幾次進行hand函數處理 
vector<int> position[maxn];//position[i]表示數字i在歐拉序中出現的位置 
vector<int> can;//can存1~n中沒有出現過的數 
int visit[maxn];
void hand(vector<int> &len, int tiny){
	times ++;//次數加1 
	static vector<int> sum;//sum[i]表示從len[0]到len[1]有多少個不是-1的數 ，類似於前綴和 
	static vector<int> Stack;//Stack模擬歐拉遊覽樹類似出棧入棧的過程 
	static set<P> line[2];//line[1]存len序列下標（i）爲奇數的i-2*sum[i-1]並排序 , line[0]存len序列下標爲偶數的i-2*sum[i-1]並排序 
	Stack.clear();Stack.push_back(tiny);//清空Stack，並把tiny先入棧 
	line[0].clear();line[1].clear();//清空 
	sum.clear();//清空 
	sum.resize(len.size());//sum的大小根據當前考慮的序列len來決定 
	sum[0] = (len[0] > 0);//先求出sum[0]的值，根據len[0]來決定 
	for(int i = 1; i < len.size(); i++){//遍歷len序列 ，把sum序列和兩個set序列確定下來 
		sum[i] = sum[i-1] + (len[i] > 0);//更新sum[i]的值 
		if(len[i] > 0){//如果len[i]的值是確定的（大於0） ，則把i-2*sum[i-1]插入set中 
			line[i&1].insert(P(i-2*sum[i-1], i));//i&1判斷下標是奇數還是偶數 ,i表示位置 
		}
	}
	for(int i = 0; i < len.size(); i++){//遍歷 len序列，把裏面沒有確定的值確定下來 
		if(len[i] > 0){//如果len[i]是已經確定的，則把它入棧 
			if(Stack.size() > 1 && Stack[Stack.size()-2] == len[i]){
			//如果棧頂元素和len[i]相同，則是ETT的出棧過程，所以len[i]不入棧，把棧頂元素出棧即可 
				Stack.pop_back();
			}
			else	Stack.push_back(len[i]);//否則把len[i]入棧 
		}
		else{//如果len[i]沒有被確定 
			int pos = len.size();//先確定len[i]是否能與len序列後面某一個元素相同，pos存那個元素的位置，先初始化爲len.size() 
			while(1){//開始尋找 
				auto p = line[i&1].lower_bound(P(i-2*sum[i], 0));
				//需要尋找的那個元素滿足兩個條件，下標奇偶性相同，(sum[pos-1]-sum[i])*2=pos-i ,pos>i
				if(p == line[i&1].end() || (*p).first != i-2*sum[i])	break;//如果找到end()的位置還找不到，說明不存在，break 
				else if((*p).second < i){
				//如果找到的這個元素的位置比len[i]的位置(i)還前面，則刪除這個元素，因爲以後它都用不着 
					line[i&1].erase(p);
				}
				else{
				//滿足條件，則把此元素的位置賦值給pos 
					pos = (*p).second;
					break;
				}
			}
			if(pos < len.size()){//如果找到一個滿足條件的元素 
				num[-len[i]] = len[pos];//那麼原序列的這個未知的值賦值爲len[pos] 
				if(visit[len[pos]] == times){
				//如果visit[len[pos]]等於times，表示在當前的len序列中之前已經出現len[pos]，棧內肯定存在len[pos]這個值，那就一直出棧知道棧頂爲len[pos]即可 
					while(Stack.back() != len[pos])	Stack.pop_back();
				}
				else{
				//否則把visit[len[pos]]賦值爲times，把len[pos]入棧 
					visit[len[pos]] = times;
					Stack.push_back(len[pos]);
				}
			}
			else{//如果找不到一個滿足條件的元素 
				if(Stack.size() > 1){//如果棧內有剩餘元素 ，就把原序列的這個未知的值賦值爲棧頂的下一個元素（不能賦值爲棧頂元素） 
					num[-len[i]] = Stack[Stack.size()-2];
					Stack.pop_back();//將棧頂元素出棧，模擬ETT遍歷 
				}
				else{
					num[-len[i]] = can.back();//否則就把原序列的這個未知的值賦值爲一個原序列未曾出現過的新元素 
					Stack.push_back(can.back());//把這個元素入棧，模擬ETT遍歷 
					can.pop_back();//把這個新元素從can中移出，表示這個元素被使用過了 
				}
			}
		}
	}
	return;
}
void solve(int l, int r, int tiny){//l，r表示子序列的左右位置，tiny表示遞歸此部分歐拉遊覽樹的根節點序號 
	if(l > r)	return;
	vector<int> len;//len來存這一子序列中-1被替代後的結果子序列 
	for(int i = l; i <= r; i++){
		if(num[i] == -1){
			len.push_back(-i);//如果位置i的數是-1，用-i來進行標記 
		}
		else{
			len.push_back(num[i]);//如果位置i的數不是-1，說明值已確定，直接放入len中 
			for(int j = 0; j < position[num[i]].size()-1; j++){
				solve(position[num[i]][j]+1, position[num[i]][j+1]-1, num[i]);//繼續遞歸解決子問題的子問題（子序列） 
			}
			i = position[num[i]].back();//由於中間一段的子序列已經被解決，所以把i跳到這一段的最後面 
		}
	}
	hand(len, tiny);//hand函數處理len中的負數 
	return;
}
int main(){
	cin >> T;//一共T組輸入 
	while(T--){
		scanf("%d", &n);
		for(int i = 1; i <= 2*n-1; i++){//輸入歐拉序 
			scanf("%d", &num[i]);
		}
		num[1] = num[2*n-1] = 1;//歐拉序開始和結束一定是1 
		for(int i = 1; i <= 2*n-1; i++){
			if(num[i] != -1)	position[num[i]].push_back(i);//把所有不是-1的數位置提取出來 
		}
		for(int i = 1; i <= n; i++){
			if(!position[i].size())	can.push_back(i);//把所有沒有使用出現過的數提取出來 
		}
		for(int i = 0; i < position[1].size() - 1; i++){
			solve(position[1][i]+1, position[1][i+1]-1, 1);//遞歸解決每一個子問題 （子串） 
		}
		for(int i = 1; i <= 2*n-1; i++){
			printf("%d ", num[i]);//輸出已經處理後的原序列 
		}
		for(int i = 1; i <= n; i++){
			position[i].clear();//清空 
		} 
		can.clear();//清空 
		printf("\n");
	}
	return 0;
}
int *zym；
發佈了49 篇原創文章 · 獲贊 91 · 訪問量 3985
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

10分鐘搞定Mysql主從部署配置

流程 Master數據庫安裝 Slave數據庫安裝 配置Master數據庫 配置Slave數據庫 網絡信息 Master數據庫IP：192.168.198.133 Slave數據庫IP：192.168.198.132 配置Maste

zer0black 2024-05-17 14:31:12

無法AC，關於使用fgets碰到的問題——末尾多一個換行符

題目是輸入一串字符串，包含空格，裏面有多個單詞，將每個單詞翻轉輸出，並且單詞之間的空格要與原文一致。 寫的時候沒有使用string的輸入，而是選擇了char數組的輸入。 樣例測試hello world->olleh dlrow是沒有問題的，

Danlis 2024-05-17 14:30:52

lightdb秒級增加列和刪除列（not null帶默認值）

　　對數據量過億的大表而言，dba最頭疼的是隨着業務變化增加帶默認值的字段，以及修改字段的數據類型，在實現不好的數據庫中，動不動執行半天，中途失敗的話，還會卡半天。這在lightdb中是不會發生的。如下所示： lightdb@oradb=

zhjh256 2024-05-17 14:28:42

lightdb mysql 8.0兼容之不可見主鍵

　　數據庫設計通常需要滿足一定的範式要求，其中主鍵更是最基本的要求。不過，數據庫管理系統卻允許我們創建沒有主鍵的表。這樣的表在數據庫中會帶來查詢性能低下、複製延遲甚至無法實現高可用配置等問題。 　　爲此，lightdb在22.1版本引入了一

zhjh256 2024-05-17 14:28:42

lightdb數據庫超時相關控制參數

　　在業務開發中，通常因爲代碼不規範、中間件缺陷、DBA誤提交批量SQL等原因，會導致服務端連接一直存在、但是實際上並未在執行的情況，從而導致數據庫連接泄露。爲了防止這種異常情況積壓，lightdb中包含了多個參數用於控制超時相關的行爲：

zhjh256 2024-05-17 14:28:42

如何使用 JS 判斷用戶是否處於活躍狀態

有時候，我們需要在網頁判斷用戶是否處與非活躍狀態，如果用戶長時間沒有在頁面上進行任何操作，我們則判定該用戶是非活躍的。 在 javascript 中我們可以通過監聽某些鼠標或鍵盤相關的事件來判定用戶是否在活躍中。 案例演示 在線演示 - 使

劉漢貴 2024-05-17 14:26:51

使用 JS 實現在瀏覽器控制檯打印圖片 console.image()

在前端開發過程中，調試的時候，我門會使用 console.log 等方式查看數據。但對於圖片來說，僅靠展示的數據與結構，是無法想象出圖片最終呈現的樣子的。 雖然我們可以把圖片數據通過 img 標籤展示到頁面上，或將圖片下載下來進行預覽。但這

劉漢貴 2024-05-17 14:26:51

基於Ubuntu-22.04安裝K8s-v1.28.2實驗（四）使用域名訪問網站應用

安裝負載均衡metalb 安裝metalb kubectl create namespace metallb-system 配置metalb #kubectl create secret generic -n metallb-system

hiningrise 2024-05-17 14:25:27

Flink的State

    有狀態的計算是流式計算框架的一個重要功能，很多複雜的計算場景都需要記錄一下相關的狀態。Flink State一種爲了滿足算子計算時需要歷史數據需求的，使用 checkpoint 機制進行容錯，存儲在 state backend 的數

人不瘋狂枉一生 2024-05-17 14:23:00

ASP.NET Core Web中使用AutoMapper進行對象映射

前言 在日常開發中，我們常常需要將一個對象映射到另一個對象，這個過程中可能需要編寫大量的重複性代碼，如果每次都手動編寫，不僅會影響開發效率，而且當項目越來越複雜、龐大的時候還容易出現錯誤。爲了解決這個問題，對象映射庫就隨之而出了，這些庫可以

追逐時光 2024-05-17 14:22:00

第四節：MySQL主從集羣搭建、擴容與數據遷移、半同步複製詳解

一.                二.                三.                  ! 作       者 : Yaopengfei(姚鵬飛) 博客地址 : http://www.cnblogs.com

Yaopengfei 2024-05-17 14:21:40

RDLC降低使用內存

在Winform使用RDLC時，在批量打印情況下，內存隨着打印任務的數量逐漸增加。即便手動GC效果也不明顯。 原因： localReport在創建時，每個實例都是一個應用程序域。租約的過期時間比較久，按照網上的資料，過期時間大約10分鐘左右

煙臺西炮臺 2024-05-17 14:21:20

❤️‍🔥 Solon Cloud Event 新的事務特性與應用

1、Solon Cloud Event？ 是 Solon 分佈式事件總線的解決方案。也是 Solon “最終一致性”分佈式事務的解決方案之一 2、事務特性 事務？就是要求 Event 有原子性，當多個 Event 發佈時，要麼全成功，要麼

劉之西東 2024-05-17 14:21:09

AI-FastGPT安裝

最近開始體驗FastGPT知識庫問答系統，參考官方文檔，在自己的阿里雲服務器使用Docker Compose快速完成了部署。 環境說明：阿里雲ECS，2核8G，X86架構，CentOS 7.9操作系統。 Docker與Docker-Com

2018 2024-05-17 14:14:58

matlab練習程序（線性常微分方程組矩陣解）

之前有通過ode和simulink解線性常微分方程組。 除了上面兩種方法，線性常微分方程組還可以通過矩陣的方法求解。 比如下面這個之前使用的方程組： x'' = x' - x + y' -z' y'' = y' - y - x' z'' =

Dsp Tian 2024-05-17 14:11:07