PDF文件公眾號回覆關鍵字:20241006
1P7910 [CSP-J 2021] 插入排序
[題目描述]
插入排序是一種非常常見且簡單的排序演算法。小 Z 是一名大一的新生，今天 H 老師剛剛在上課的時候講了插入排序演算法。
假設比較兩個元素的時間為 O(1)，則插入排序可以以 O(n^2) 的時間複雜度完成長度為 n 的陣列的排序。不妨假設這 n個數字分別儲存在 a1,a2,…,an之中，則如下虛擬碼給出了插入排序演算法的一種最簡單的實現方式
for (int i = 1; i <= n; i++)
for (int j = i; j >= 2; j--)
if (a[j] < a[j-1]) {
int t = a[j-1];
a[j-1] = a[j];
a[j] = t;
}
為了幫助小 Z 更好的理解插入排序，小 Z 的老師 H 老師留下了這麼一道家庭作業：
H 老師給了一個長度為 n 的陣列 a，陣列下標從 1開始，並且陣列中的所有元素均為非負整數。小 Z 需要支援在陣列 a上的 Q 次操作，操作共兩種，引數分別如下為了幫助小 Z 更好的理解插入排序，小 Z 的老師 H 老師留下了這麼一道家庭作業：
H 老師給了一個長度為 n的陣列 a，陣列下標從 1 開始，並且陣列中的所有元素均為非負整數。小 Z 需要支援在陣列 a上的 Q 次操作，操作共兩種，引數分別如下
x v：這是第一種操作，會將 a 的第 x 個元素，也就是 ax 的值，修改為 v。保證 1≤x≤n，1≤v≤10^9。注意這種操作會改變陣列的元素，修改得到的陣列會被保留，也會影響後續的操作
x：這是第二種操作，假設 H 老師按照上面的虛擬碼對 a 陣列進行排序，你需要告訴 H 老師原來 a 的第 x 個元素，也就是 ax，在排序後的新陣列所處的位置。保證 1≤x≤n。注意這種操作不會改變陣列的元素，排序後的陣列不會被保留，也不會影響後續的操作
H 老師不喜歡過多的修改，所以他保證型別 1 的操作次數不超過 5000
小 Z 沒有學過計算機競賽，因此小 Z 並不會做這道題。他找到了你來幫助他解決這個問題
[輸入格式]
第一行，包含兩個正整數 n,Q，表示陣列長度和操作次數。
第二行，包含 n 個空格分隔的非負整數，其中第 i 個非負整數表示 ai
接下來 Q 行，每行 2∼3個正整數，表示一次操作
[輸出格式]
對於每一次型別為 2 的詢問，輸出一行一個正整數表示答案
[輸入輸出樣例]
輸入 #1
3 4
3 2 1
2 3
1 3 2
2 2
2 3
輸出 #1
1
1
2
說明/提示
在修改操作之前，假設 H 老師進行了一次插入排序，則原序列的三個元素在排序結束後所處的位置分別是 3,2,1。
在修改操作之後，假設 H 老師進行了一次插入排序，則原序列的三個元素在排序結束後所處的位置分別是 3,1,2。
注意雖然此時 a2=a3，但是我們不能將其視為相同的元素
資料規模
對於所有測試資料，滿足 1≤n≤8000，1≤Q≤2×10^5，1≤x≤n，1≤v, ai≤10^9。
對於所有測試資料，保證在所有 Q 次操作中，至多有 5000 次操作屬於型別一
2 相關知識點
1) 排序穩定性
穩定排序
排序後 2 個相等鍵值的順序和排序之前它們的順序相同
不穩定
排序後 2 個相等鍵值的順序和排序之前它們的順序不相同
排序前
排序後
穩定
排序後
不穩定
2) 結構體
結構體屬於使用者自定義的資料型別，允許使用者儲存不同的資料型別
例如：
學生有姓名/年齡/分數，其中，姓名和年齡/分數是不同型別，因此不能使用陣列準確儲存
建立結構體
建立一個新的學生資料型別：學生包括（姓名，年齡，分數）
struct Student{
//成員列表
//姓名
string name;
//年齡
int age;
//分數
int score;
};
宣告結構體型別
Student s1;
結構體賦值
s1.name = "張三";
s1.age = 18;
s1.score = 100;
整體示例參考
#include <bits/stdc++.h>
using namespace std;
/*建立學生資料型別
struct 型別名稱 { 成員列表 }
*/
struct Student{
//成員列表
//姓名
string name;
//年齡
int age;
//分數
int score;
}S[10];//定義以Student為型別的陣列S
int main(){
Student s1; //宣告結構體變數
//給s1屬性賦值，透過.訪問結構體變數中的屬性
s1.name = "張三";
s1.age = 18;
s1.score = 100;
cout << "姓名：" << s1.name << "年齡：" << s1.age << "分數：" << s1.score << endl;
Student s2 = { "李四" , 19 , 80 };//宣告結構體變數並賦值
cout << "姓名：" << s1.name << "年齡：" << s1.age << "分數：" << s1.score << endl;
//結構體陣列
S[0].name = "王五";
S[0].age = 30;
S[0].score = 98;
cout << "姓名：" << S[0].name << "年齡：" << S[0].age << "分數：" << S[0].score << endl;
return 0;
}
3) sort排序
sort是c++ algorithm 庫裡的一個排序函式，平均時間複雜度為O(n*log n)
基本用法
sort(起始地址，末尾地址+1)；
sort(起始地址，末尾地址+1，cmp)；
#include<iostream>
#include<algorithm> //使用sort等演算法函式需要的標頭檔案
using namespace std;
void print(int a[]){//列印函式
for(int i=0;i<10;i++){
cout<<a[i]<<' ';
}
cout<<endl;
}
bool cmp(int a1,int a2){//大於號是升序排序，小於號是降序排序
return a1>a2;
}
int main(){
int a[10]={3,1,4,5,8,0,9,2,7,6};
cout<<"排序前："<<endl;
print(a); //列印
sort(a,a+10);//排序，預設是升序的
cout<<"排序後："<<endl;
print(a); //列印
sort(a,a+10,cmp);//自定義排序
cout<<"自定義降序："<<endl;
print(a);
}
/*
輸出
排序前：
3 1 4 5 8 0 9 2 7 6
排序後：
0 1 2 3 4 5 6 7 8 9
自定義降序：
9 8 7 6 5 4 3 2 1 0
*/
4) 計數排序
計數排序（Counting Sort）是一種線性時間複雜度的排序演算法，適用於整數排序且待排序的元素範圍相對較小的情況。它的基本思想是透過統計每個元素出現的次數，然後根據統計資訊將元素放回原陣列的正確位置，從而實現排序
例題
如下幾個數字進行計數排序
5 6 8 3 2 4
宣告陣列a[10]={0},分別把上面數字作為a數字下標，值為當前數+1
賦值後陣列如下
下標 0 1 2 3 4 5 6 7 8 9
數值 0 0 1 1 1 1 1 0 1 0
逐一輸出不為0的數的下標，如果值大於1，輸出多次
計數排序，是對雜湊直接定址法的變形應用,具體思路為:統計相同元素出現次數,根據統計的結果將序列回收到原來的序列中
#include<bits/stdc++.h>
using namespace std;
int main(){
int a[10]={3,4,2,7,5,4,3,3,3,5};
int cnt[7]={0};//cnt陣列記錄對應下標出現次數
for(int i=0;i<10;i++){
cnt[a[i]]++;
}
for(int i=0;i<=7;i++){//列舉對應範圍的數 從最小到最大，本示例從0~7即可
while(cnt[i]>0){//一個數字出現多次時，cnt[i]為對應的數為出現幾次
cout<<i<<" ";
cnt[i]--;
}
}
return 0;
}
/*
輸出
2 3 3 3 3 4 4 5 5 7
*/
3 思路分析
思路1
1 多次詢問，且中間可能會修改陣列
2 每次詢問，計算1次排序後的位置
3 計算位置，找出所有比自己小的，即去除前面比自己大的+後比自己小的
示例程式
#include<bits/stdc++.h>
using namespace std;
const int maxN=8010;//陣列元素個數
/*
n輸入n個數
Q進行q次操作
opt輸入操作型別 1 修改 2 詢問位置
x 修改的位置 v修改的值
leftCnt修改數前面大於該數的個數
rightCnt修改數後面小於該數的個數
*/
int n,Q,opt,x,v,leftCnt,rightCnt;
int a[maxN];//儲存輸入數的陣列
int main(){
cin>>n>>Q;//輸入n個數和Q次操作
for(int i=1;i<=n;i++){//逐一輸入n個數
cin>>a[i];
}
for(int i=1;i<=Q;i++){//逐一輸入和處理Q次操作
cin>>opt;//輸入操作型別 修改
if(opt==1){
cin>>x>>v;//輸入修改位置x和修改數v
a[x]=v;//修改x位置的數為v
}
if(opt==2){//詢問
cin>>x;//輸入x在排序後的位置
leftCnt=rightCnt=0;//初始為0
for(int i=1;i<x;i++){//x位置前面的大的累加
if(a[i]>a[x]){
leftCnt++;
}
}
for(int i=x+1;i<=n;i++){//x位置後面小的累加
if(a[i]<a[x]){
rightCnt++;
}
}
//當前位置:去除前面大的+上後面小的
cout<<x-leftCnt+rightCnt<<endl;
}
}
}
由於此思路花費時間主要在詢問位置時，詢問位置的次數在2*10^5-5000左右，每次詢問時間複雜度為O(n),n最大為8000，因此肯定會超時
思路2
1 由於修改次數比較少，每次修改後計算所有元素排序後位置
2 使用結構體，記錄元素在原陣列的下標
3 先對陣列進行排序，使用t陣列透過計數排序記錄原陣列元素，在排序後陣列的位置
4 修改原陣列下標x在排序後陣列中的值，並對x左邊進行排序，對應x右邊進行排序，使整個陣列有序
5 排序後重新維護t陣列
6 詢問x位置時，直接輸出t[x]
示例程式
#include<bits/stdc++.h>
using namespace std;
const int maxN=8010;//陣列元素個數
/*
結構體 id 輸入的原始位置
num 輸入的數
*/
struct node{
int id;
int num;
}a[maxN];//儲存待排序數
/*
t[i] 原數字i位置在排序後陣列的中的位置
n 輸入結果數
Q 進行操作次數
*/
int t[maxN],n,Q;
/*
opt輸入操作型別 1 修改 2 詢問位置
x 修改的位置 v修改的值
*/
int opt,x,v;
/*
比較函式
按結構體node 中num從小到大排序
node1.num<node2.num return true
如果num相同，按結構體node中id從小到大排序
node1.id<node2.id return true
*/
bool cmp(node node1,node node2){
if(node1.num!=node2.num){
return node1.num<node2.num;
}else{
return node1.id<node2.id;
}
}
int main(){
cin>>n>>Q;//輸入n個數和Q次操作
for(int i=1;i<=n;i++){//逐一輸入n個數
cin>>a[i].num;
a[i].id=i;
}
/*
按結構體node 中num從小到大排序
如果num相同，按結構體node中id從小到大排序
*/
sort(a+1,a+n+1,cmp);
//初始原陣列對應數在排序後陣列中的位置
for(int i=1;i<=n;i++){
t[a[i].id]=i;
}
for(int i=1;i<=Q;i++){//Q次操作
cin>>opt;//輸入操作型別
if(opt==1){//修改
cin>>x>>v;//輸入修改位置x和修改數v
a[t[x]].num=v;//修改x位置的數為v
/*
如果修改數位置後面有比v小的數
逐一交換，保證從小到大排序
*/
for(int j=t[x];j<n;j++){
if(cmp(a[j+1],a[j])){
node tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
/*
如果修改數位置前面有比v大的數
逐一交換，保證從小到大排序
*/
for(int j=t[x];j>1;j--){
if(cmp(a[j],a[j-1])){
node tmp=a[j];
a[j]=a[j-1];
a[j-1]=tmp;
}
}
//逐一把原陣列元素位置對應新陣列位置
for(int j=1;j<=n;j++){
t[a[j].id]=j;
}
}
if(opt==2){//操作為詢問
cin>>x;//輸入詢問位置
cout<<t[x]<<endl;//輸出在新陣列中位置
}
}
return 0;
}
思路2的最佳化思路，把每次詢問計算邏輯改動每次修改後進行計算儲存，修改的次數最多為5000，O(n)的時間複雜度不會超時
每次詢問時直接從陣列讀取，時間複雜度為O(1),效率明顯提升
思路2讀入最佳化
在思路2基礎上，使用scanf代替cin，大資料讀入時，效率提升40%~50%
示例程式
#include<bits/stdc++.h>
using namespace std;
const int maxN=8010;//陣列元素個數
/*
結構體 id 輸入的原始位置
num 輸入的數
*/
struct node{
int id;
int num;
}a[maxN];//儲存待排序數
/*
t[i] 原數字i位置在排序後陣列的中的位置
n 輸入結果數
Q 進行操作次數
*/
int t[maxN],n,Q;
/*
opt輸入操作型別 1 修改 2 詢問位置
x 修改的位置 v修改的值
*/
int opt,x,v;
/*
比較函式
按結構體node 中num從小到大排序
node1.num<node2.num return true
如果num相同，按結構體node中id從小到大排序
node1.id<node2.id return true
*/
bool cmp(node node1,node node2){
if(node1.num!=node2.num){
return node1.num<node2.num;
}else{
return node1.id<node2.id;
}
}
int main(){
scanf("%d%d",&n,&Q);//cin>>n>>Q;//輸入n個數和Q次操作
for(int i=1;i<=n;i++){//逐一輸入n個數
scanf("%d",&a[i].num);//cin>>a[i].num;
a[i].id=i;
}
/*
按結構體node 中num從小到大排序
如果num相同，按結構體node中id從小到大排序
*/
sort(a+1,a+n+1,cmp);
//初始原陣列對應數在排序後陣列中的位置
for(int i=1;i<=n;i++){
t[a[i].id]=i;
}
for(int i=1;i<=Q;i++){//Q次操作
scanf("%d",&opt);//cin>>opt;//輸入操作型別
if(opt==1){//修改
scanf("%d%d",&x,&v);//cin>>x>>v;//輸入修改位置x和修改數v
a[t[x]].num=v;//修改x位置的數為v
/*
如果修改數位置後面有比v小的數
逐一交換，保證從小到大排序
*/
for(int j=t[x];j<n;j++){
if(cmp(a[j+1],a[j])){
node tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
/*
如果修改數位置前面有比v大的數
逐一交換，保證從小到大排序
*/
for(int j=t[x];j>1;j--){
if(cmp(a[j],a[j-1])){
node tmp=a[j];
a[j]=a[j-1];
a[j-1]=tmp;
}
}
//逐一把原陣列元素位置對應新陣列位置
for(int j=1;j<=n;j++){
t[a[j].id]=j;
}
}
if(opt==2){//操作為詢問
scanf("%d",&x);//cin>>x;//輸入詢問位置
printf("%d\n",t[x]);//cout<<t[x]<<endl;//輸出在新陣列中位置
}
}
return 0;
}
讀入最佳化後，效率進一步提升，可以觀察其中測試用例，從323ms下降到201ms
