深度理解鏈式前向星
我們首先來看一下什麽是前向星.
前向星是一種特殊的邊集數組,我們把邊集數組中的每一條邊按照起點從小到大排序,如果起點相同就按照終點從小到大排序,
並記錄下以某個點為起點的所有邊在數組中的起始位置和存儲長度,那麽前向星就構造好了.
用len[i]來記錄所有以i為起點的邊在數組中的存儲長度.
用head[i]記錄以i為邊集在數組中的第一個存儲位置.
那麽對於下圖:
我們輸入邊的順序為:
1 2
2 3
3 4
1 3
4 1
1 5
4 5
那麽排完序後就得到:
編號: 1 2 3 4 5 6 7
起點u: 1 1 1 2 3 4 4
終點v: 2 3 5 3 4 1 5
得到:
head[1] = 1 len[1] = 3
head[2] = 4 len[2] = 1
head[3] = 5 len[3] = 1
head[4] = 6 len[4] = 2
但是利用前向星會有排序操作,如果用快排時間至少為O(nlog(n))
如果用鏈式前向星,就可以避免排序.
我們建立邊結構體為:
struct Edge
{
int next;
int to;
int w;};
其中edge[i].to表示第i條邊的終點,edge[i].next表示與第i條邊同起點的下一條邊的存儲位置,edge[i].w為邊權值.
另外還有一個數組head[],它是用來表示以i為起點的第一條邊存儲的位置,實際上你會發現這裏的第一條邊存儲的位置其實
在以i為起點的所有邊的最後輸入的那個編號.
head[]數組一般初始化為-1,對於加邊的add函數是這樣的:
void add(int u,int v,int w)
{
edge[cnt].w = w;
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}初始化cnt = 0,這樣,現在我們還是按照上面的圖和輸入來模擬一下:
edge[0].to = 2; edge[0].next = -1; head[1] = 0;
edge[1].to = 3; edge[1].next = -1; head[2] = 1;
edge[2].to = 4; edge[2],next = -1; head[3] = 2;
edge[3].to = 3; edge[3].next = 0; head[1] = 3;
edge[4].to = 1; edge[4].next = -1; head[4] = 4;
edge[5].to = 5; edge[5].next = 3; head[1] = 5;
edge[6].to = 5; edge[6].next = 4; head[4] = 6;
很明顯,head[i]保存的是以i為起點的所有邊中編號最大的那個,而把這個當作頂點i的第一條起始邊的位置.
這樣在遍歷時是倒著遍歷的,也就是說與輸入順序是相反的,不過這樣不影響結果的正確性.
比如以上圖為例,以節點1為起點的邊有3條,它們的編號分別是0,3,5 而head[1] = 5
我們在遍歷以u節點為起始位置的所有邊的時候是這樣的:
for(int i=head[u];~i;i=edge[i].next)
那麽就是說先遍歷編號為5的邊,也就是head[1],然後就是edge[5].next,也就是編號3的邊,然後繼續edge[3].next,也
就是編號0的邊,可以看出是逆序的.
【存儲】淺談鏈式前向星
鏈式前向星是一種相當有效的存儲方式，是一種靜態的鏈表式存儲，將前向星改寫為鏈式前向星可以避免排序帶來的復雜度（普通前向星需要排序，一般選用基數排序），以下開始討論鏈式前向星。
在本文中，除非特別註明，我們都以下圖作為討論的基本依據：
對於這個圖而言，有一輸入順序如下：
1 2
2 3
3 4
1 3
4 1
1 5
4 5首先，我們先提出鏈式前向星的基本結構：
struct Edge2
{
int to;
int next;
int w;
};
Edge2 Edge[maxn];對於next：
如果一個結點的出度大於1，則其中結點編號最大的結點的next將指向結點編號次之的結點。舉個例子，從結點1出發，結點編號最大的是結點5，結點5的next將會是3，而結點3的next將會是結點2，而到了結點2之後結點1的所有出邊都已經被處理了，所有結點2的next將會是-1，這樣子將可以找到對於結點1的所有直接相接的結點（註意：遍歷時結點是由大到小遍歷的，即是逆序的）。當檢測到next的值為-1時會退出當前遍歷。
如果結點的出度為0或者小於1，則對應的next值為-1。推薦用筆在紙上模擬一次這個過程，模擬過程的數據可以在該文章後面一些的地方找到。對於to：
簡單概括來說就是對於第i條邊的終點，比如說輸入第一組邊（1， 2）的時候，Edge[0].to = 2（數組從0開始存儲）。
這裏有一個要註意的點，如果是有向圖，那麽只要處理一次就夠了。對於一個無向圖的話，就需要來回存一次，對於無向圖的具體存法可以看文末給出的題目和相關代碼。對於weight：
很明顯這個就是用來存邊的權重的一個變量，這裏不再多討論。
然後，我們還需要一個head數組，這個head數組和next是這個鏈式存儲結構的關鍵所在！
那麽這個head數組用來存什麽呢？對於你輸入的邊，用來存以i為起點的邊的存儲位置。那麽如果以i為起點的邊出度大於1怎麽辦？此時head[i]會存入在輸入中最後輸入的以i為起點的編號。比如說對於結點1，它的出度為3，由先往後分別輸入了（1， 2）（1， 3）（1， 5），最後存入head的就會是5（2和3其實也有被存儲的時候，但是後來會被5覆蓋掉），即結果就是head[1] = 5。對於輸入的邊的存儲方式如下：
void Build(int u, int v, int w){
Edge[k].to = v;
Edge[k].weight = w;
Edge[k].next = head[u];
head[u] = k++;
} 這個讀入的過程同樣推薦用筆算一次，可以很好的幫助理解。這裏提一下關於head[u]的問題，以以1為起點的邊為例子，第一次讀入（1，2）的時候，很明顯，head[u] = -1的，即head[1] = -1。那麽下面的head[u]又是幹什麽的呢？還是以“以1為起點的邊”作為例子，（1， 2）的時候，head[1] = -1；然後在“head[u] = k++”這一行把這個值記錄下來，簡單來說就是u這個值在第幾組輸入的邊裏出現過，放到這個例子裏就是head[1] = 0;而後，讀入（1，3）（1，5）的時候， head[1]的值會再次被刷新，最後得出的head[1] = 5。樣例數據：
edge[0].to = 2; edge[0].next = -1; head[1] = 0;
edge[1].to = 3; edge[1].next = -1; head[2] = 1;
edge[2].to = 4; edge[2],next = -1; head[3] = 2;
edge[3].to = 3; edge[3].next = 0; head[1] = 3;
edge[4].to = 1; edge[4].next = -1; head[4] = 4;
edge[5].to = 5; edge[5].next = 3; head[1] = 5;
edge[6].to = 5; edge[6].next = 4; head[4] = 6;那麽它是怎麽進行遍歷的呢？這裏我們以Luogu2420作為例子：
void solve(int num){
for(int i = head[num]; i != -1; i = Edge[i].next)
if(!visit[Edge[i].start])
{
visit[Edge[i].start] = true;
dis[Edge[i].start] = dis[num]^Edge[i].weight;
solve(Edge[i].start);
}
}主要分兩塊，一塊就是循環體，一塊是遞歸體。
轉回上文中有向圖的實例，循環的主要作用就是對擁有同一起點的邊進行跳轉（比如說從（1，5）轉到（1， 3）再轉到（1， 2），就是我前文所寫的next的作用，相當於一個靜態的鏈表），而遞歸體主要就是DFS（比如說從（1， 3）到（3， 4）再到（4， 5）再到（4， 1），這裏同樣推薦用筆寫一寫，會清晰很多）。這樣子我們就成功使用鏈式前向星來存下了一個圖，並能夠對它進行遍歷。
然後也有一道不錯的題可以用鏈式前向星來做，比如上文提到的Luogu2420（其實我就是因為這道題才知道這個的...），可以去做一下，代碼放在另一篇博文裏，這裏就不多提及了。參考資料：
https://blog.csdn.net/m0_37389559/article/details/75200652
https://malash.me/200910/linked-forward-star/
題目鏈接：
https://www.luogu.org/problemnew/show/P2420
代碼鏈接：
https://oi-liu.com/2018/04/20/p2420
深度理解鏈式前向星