2. 程式人生 > >題解 P1949 【聰明的打字員_NOI導刊2011提高（10）】

題解 P1949 【聰明的打字員_NOI導刊2011提高（10）】

阿新 • • 發佈：2018-12-03

題目描述

阿蘭是某機密部門的打字員，她現在接到一個任務：需要在一天之內輸入幾百個長度固定為6的密碼。當然，她希望輸入的過程中敲擊鍵盤的總次數越少越好。

不幸的是，出於保密的需要，該部門用於輸入密碼的鍵盤是特殊設計的，鍵盤上沒有數字鍵，而只有以下六個鍵：swap0,swap1,up,down,left,right。為了說明這6個鍵的作用，我們先定義錄入區的6個位置的編號，從左至右依次為1,2,3,4,5,6。下面列出每個鍵的作用：

swap0：按swap0，游標位置不變，將游標所在的位置的數字與錄入區的1號位置的數字(左起第一個數字)交換。如果游標已經處在錄入區的1號位置，則按swap0鍵之後錄入區的數字不變。

swap1：按swap1，游標位置不變，將游標所在位置的數字與錄入區的6號位置的數字（左起第六個數字）交換。如果游標已經處在錄入區的6號位置，則按swap1鍵之後錄入區的數字不變。

up：按up，游標位置不變，講游標所在位置的數字加1（除非該數字是9）。例如，如果游標所在位置的數字為2，按up之後，該處的數字變為3；如果游標所在位置的數字為9，按up之後，該處的數字不變，游標位置也不變；

down：按down，游標位置不變，講游標所在位置的數字減1（除非該數字是0）。如果游標所在位置的數字為0，按down之後，該處的數字不變，游標位置也不變；

left：按left，游標左移一個位置，如果游標已在錄入區的1號位置（左起第一個位置）上，則游標不動；

right：按right，游標右移一個位置，如果游標已在錄入區的6號位置（左起第六個位置）上，則游標不動；

當然，為了使這樣的鍵盤發揮作用，每次錄入密碼之前，錄入區總會隨機出現一個長度為6的初始密碼，而且游標會固定出現在1號位置上。當巧妙的使用上述六個特殊鍵之後，可以得到目標密碼，這時游標允許停留在任何一個位置。

現在，阿蘭需要你的幫助，編寫一個程式，求出錄入一個密碼需要的最少的擊鍵次數。

輸入輸出格式

輸入格式：

僅一行，含有兩個長度為6的數，前者為初始密碼，後者為目標密碼，兩個密碼之間用一個空格隔開。

輸出格式：

僅一行，含有一個正整數，為最少需要的擊鍵次數。

輸入輸出樣例

輸入樣例#1：

123456 654321

輸出樣例#1：

11

主要思路：BFS + 迴圈佇列

這個題的數只有6位，我們直接當六位數存不就好了

首先不能寫DFS，明顯這題BFS要比DFS更優（DFS不就退化成了窮舉嗎（大霧））

swap0，swap1，up，down操作，直接模擬就好，left和right就更好辦了，直接更新游標左右就好。

code#1:36分（肯定TLE了）

福利：自帶野生debug程式碼

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;
#define go(i,j,n,k) for(int i=j;i<=n;i+=k)
#define fo(i,j,n,k) for(int i=j;i>=n;i-=k)
inline ll read(){
    ll x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-f;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void fre() {
    freopen(".in", "r", stdin);
    freopen(".out", "w", stdout);
}
int st, ed;
int vis[1000100][7]; // 判重陣列

inline int swap0(int x, int now) {
    int res = 1;
    now = 6 - now + 1;
    go(i, 1, now - 1, 1) res *= 10;
    int xx = (x / res) % 10;
    int yy = (x / 100000);
    int ans = x;
    ans -= xx * res;
    ans -= yy * 100000;
    ans += xx * 100000;
    ans += yy * res;
    return ans;
}
inline int swap1(int x, int now) {
    int res = 1;
    now = 6 - now + 1;
    go(i, 1, now - 1, 1) res *= 10;
    int xx = (x / res) % 10;
    int yy = x % 10;
    int ans = x;
    ans -= xx * res;
    ans -= yy;
    ans += xx;
    ans += yy * res;
    return ans;
}
inline int up(int x, int now) {
    int res = 1;
    now = 6 - now + 1;
    go(i, 1, now - 1, 1) res *= 10;
    int ju = (x / res) % 10;
    if(ju == 9) return x;
    return x + res;
}
inline int down(int x, int now) {
    int res = 1;
    now = 6 - now + 1;
    go(i, 1, now - 1, 1) res *= 10;
    int ju = (x / res) % 10;
    if(ju == 0) return x;
    return x - res;
}
// 四種操作
inline void debug() {
    puts("debug模式：");
    puts("1.swap0  2.swap1");
    puts("3.up     4.down");
    int s = read(), st = read(), now = read();
    if(s == 1) {
        cout << swap0(st, now) << "\n";
    } else if(s == 2) {
        cout << swap1(st, now) << "\n";
    } else if(s == 3) {
        cout << up(st, now) << "\n";
    } else if(s == 4) {
        cout << down(st, now) << "\n";
    }
}

struct node{
    int x, now, dep;
    node(int _x = 0, int _now = 0, int _dep = 0) : x(_x), now(_now), dep(_dep) {}
    node() : node(0, 0, 0) {}
};
queue<node> q;
inline int bfs(int st, int ed) {
    q.push(node(st, 1, 0));
    while(!q.empty()) {
        node get = q.front(); q.pop();
        int oo, x = get.x, now = get.now, deep = get.dep;
        vis[x][now] = 1;
        if(x == ed)
            return deep;
        oo = swap0(x, now);
        if(!vis[oo][now]) q.push(node(oo, now, deep + 1));
        oo = swap1(x, now);
        if(!vis[oo][now]) q.push(node(oo, now, deep + 1));
        oo = up(x, now);
        if(!vis[oo][now]) q.push(node(oo, now, deep + 1));
        oo = down(x, now);
        if(!vis[oo][now]) q.push(node(oo, now, deep + 1));
        if(now > 1 && !vis[x][now - 1]) q.push(node(x, now - 1, deep + 1)); // 注意這裡的特判！now不能越界！
        if(now < 6 && !vis[x][now + 1]) q.push(node(x, now + 1, deep + 1)); // 注意這裡的特判！now不能越界！
    }
}

int main(){
    //fre();
    // while(1) 
    //  debug();
    st = read(), ed = read();
    if(st == ed) {
        cout << "0\n";
        return 0;
    }
    cout << bfs(st, ed) << "\n";
    return 0;
}

為什麼會TLE？

首先，儘管我們在入隊之前就已經判重了，但是這個程式碼會重複插一樣的點，所以我們可以在從佇列中取出時來再次判重。

而且，眾所周知，有種說法說STL很慢，所以我好奇的自己手寫了個佇列。

code#2:72分（這次WA了）

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define go(i,j,n,k) for(int i=j;i<=n;i+=k)
#define fo(i,j,n,k) for(int i=j;i>=n;i-=k)
#define mn 10000100
inline ll read(){
    ll x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-f;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void fre() {
    freopen(".in", "r", stdin);
    freopen(".out", "w", stdout);
}
int st, ed;
bool vis[1000100][7]; // 判重陣列 
int ans = inf;
int ress[7] = {0, 1, 10, 100, 1000, 10000, 100000};

inline int swap0(int x, int now) {
    now = 6 - now + 1;
    int res = ress[now];
    int xx = (x / res) % 10;
    int yy = (x / 100000);
    int ans = x;
    ans -= xx * res;
    ans -= yy * 100000;
    ans += xx * 100000;
    ans += yy * res;
    return ans;
}
inline int swap1(int x, int now) {
    now = 6 - now + 1;
    int res = ress[now];
    int xx = (x / res) % 10;
    int yy = x % 10;
    int ans = x;
    ans -= xx * res;
    ans -= yy;
    ans += xx;
    ans += yy * res;
    return ans;
}
inline int up(int x, int now) {
    now = 6 - now + 1;
    int res = ress[now];
    int ju = (x / res) % 10;
    if(ju == 9) return x;
    return x + res;
}
inline int down(int x, int now) {
    now = 6 - now + 1;
    int res = ress[now];
    int ju = (x / res) % 10;
    if(ju == 0) return x;
    return x - res;
}

inline void debug() {
    puts("debug模式：");
    puts("1.swap0  2.swap1");
    puts("3.up     4.down");
    int s = read(), st = read(), now = read();
    if(s == 1) {
        cout << swap0(st, now) << "\n";
    } else if(s == 2) {
        cout << swap1(st, now) << "\n";
    } else if(s == 3) {
        cout << up(st, now) << "\n";
    } else if(s == 4) {
        cout << down(st, now) << "\n";
    }
}
// 手寫佇列哦QwQ
int X[mn], Now[mn], dep[mn], head = 1, tail = 0;
int x, now, oo, deep;
inline int bfs(int st, int ed) {
    ++tail, X[tail] = st, Now[tail] = 1, dep[tail] = 0;
    while(head <= tail) {
        x = X[head], now = Now[head], deep = dep[head]; head++;
        // cout << x << " " << now << " " << deep << "\n";
        if(vis[x][now]) continue; // 呼叫前再次判重
        vis[x][now] = 1;
        if(x == ed) return deep;
        oo = swap0(x, now);
        if(!vis[oo][now]) ++tail, X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        oo = swap1(x, now);
        if(!vis[oo][now]) ++tail, X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        oo = up(x, now);
        if(!vis[oo][now]) ++tail, X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        oo = down(x, now);
        if(!vis[oo][now]) ++tail, X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        if(now > 1 && !vis[x][now - 1]) ++tail, X[tail] = x, Now[tail] = now - 1, dep[tail] = deep + 1;
        if(now < 6 && !vis[x][now + 1]) ++tail, X[tail] = x, Now[tail] = now + 1, dep[tail] = deep + 1;
    }
    return deep + 1;
}
int main(){
    st = read(), ed = read();
    if(st == ed) {
        cout << "0\n";
        return 0;
    }
    cout << bfs(st, ed) << "\n";
    return 0;
}

怎麼還不AC

我們可以試著把陣列開大點，咦？多了9分？

好像是陣列大小？？但是我的空間已經開到最大了啊

這個時候就可以用迴圈佇列卡空間了

具體寫法看程式碼

code#3:100分

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define go(i,j,n,k) for(int i=j;i<=n;i+=k)
#define fo(i,j,n,k) for(int i=j;i>=n;i-=k)
#define mn 10000100
inline ll read(){
    ll x=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-f;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void fre() {
    freopen(".in", "r", stdin);
    freopen(".out", "w", stdout);
}
int st, ed;
bool vis[1000100][7]; // 判重陣列 
int ress[7] = {0, 1, 10, 100, 1000, 10000, 100000};
int res, xx, yy, ans, ju;
inline int swap0(int x, int now) {
    now = 6 - now + 1;
    res = ress[now];
    xx = (x / res) % 10;
    yy = (x / 100000);
    ans = x;
    ans -= xx * res;
    ans -= yy * 100000;
    ans += xx * 100000;
    ans += yy * res;
    return ans;
}
inline int swap1(int x, int now) {
    now = 6 - now + 1;
    res = ress[now];
    xx = (x / res) % 10;
    yy = x % 10;
    ans = x;
    ans -= xx * res;
    ans -= yy;
    ans += xx;
    ans += yy * res;
    return ans;
}
inline int up(int x, int now) {
    now = 6 - now + 1;
    res = ress[now];
    ju = (x / res) % 10;
    if(ju == 9) return x;
    return x + res;
}
inline int down(int x, int now) {
    now = 6 - now + 1;
    res = ress[now];
    ju = (x / res) % 10;
    if(ju == 0) return x;
    return x - res;
}

inline void debug() {
    puts("debug模式：");
    puts("1.swap0  2.swap1");
    puts("3.up     4.down");
    int s = read(), st = read(), now = read();
    if(s == 1) {
        cout << swap0(st, now) << "\n";
    } else if(s == 2) {
        cout << swap1(st, now) << "\n";
    } else if(s == 3) {
        cout << up(st, now) << "\n";
    } else if(s == 4) {
        cout << down(st, now) << "\n";
    }
}

int X[mn], Now[mn], dep[mn], head = 0, tail = 0;
int x, now, oo, deep;
inline int bfs(int st, int ed) {
    ++tail, X[tail] = st, Now[tail] = 1, dep[tail] = 0;
    while(head != tail) { // 這裡就不能是head <= tail了
        ++head;
        if(head > 10000000) head = 0; // 記得迴圈
        x = X[head], now = Now[head], deep = dep[head]; 
        // cout << x << " " << now << " " << deep << "\n";
        if(x == ed) return deep;
        if(vis[x][now]) continue;
        vis[x][now] = 1;
        oo = swap0(x, now);
        if(!vis[oo][now]) {   // 都要迴圈的QAQ
            if(++tail > 10000000) tail = 0;
            X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        }
        oo = swap1(x, now);
        if(!vis[oo][now]) {
            if(++tail > 10000000) tail = 0;
            X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        }
        oo = up(x, now);
        if(!vis[oo][now]) {
            if(++tail > 10000000) tail = 0;
            X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        }
        oo = down(x, now);
        if(!vis[oo][now]) {
            if(++tail > 10000000) tail = 0;
            X[tail] = oo, Now[tail] = now, dep[tail] = deep + 1;
        }
        if(now > 1 && !vis[x][now - 1]) {
            if(++tail > 10000000) tail = 0; 
            X[tail] = x, Now[tail] = now - 1, dep[tail] = deep + 1;
        }
        if(now < 6 && !vis[x][now + 1]) {
            if(++tail > 10000000) tail = 0; 
            X[tail] = x, Now[tail] = now + 1, dep[tail] = deep + 1;
        }
    }
    return deep + 1;
}

int main(){
    st = read(), ed = read();
    if(st == ed) {
        cout << "0\n";
        return 0;
    }
    cout << bfs(st, ed) << "\n";
    return 0;
}

希望可以幫到被卡空間的同學

相關推薦

題解 P1949 【聰明的打字員_NOI導刊2011提高（10）】

題目描述 阿蘭是某機密部門的打字員，她現在接到一個任務：需要在一天之內輸入幾百個長度固定為6的密碼。當然，她希望輸入的過程中敲擊鍵盤的總次數越少越好。 不幸的是，出於保密的需要，該部門用於輸入密碼的鍵盤是特殊設計的，鍵盤上沒有數字鍵，而只有以下六個鍵：swap0,swap1,up,down,left,ri

P1942 詞編碼_NOI導刊2011提高（10）

C++黨的福音系列 其實這道題的題意有點亂。我在這裡總結一下題意。 一個未知的01串，通過一次某種的變換，能夠變成轉換後的單詞（輸入的單詞）。你的任務是倒推出轉換前的單詞。 可能有多解，但是正向轉換的時候有考慮順序：操作4（不改變）最優先，否則按操作1、2、3順序為優先順序。 操作2的時候先嚐試刪0，

題解 P1801 【黑匣子_NOI導刊2010提高（06）】

amp 平衡樹 clu 實現 cto ctype 一位 mark 排序 我看正解已經有一大堆了，我就發個不太正經的吧 最近不會高級數據結構的蒟蒻在搞STL，搞完普通平衡樹後就看到了這道題，本來想用黑科技pb_ds中的紅黑樹做的，發現已經有大佬貼了一篇。set的做法也有人發

洛谷 P1835 素數密度_NOI導刊2011提高（04）題解

ios esp 最大 輸入輸出 void scan max 素數 賦值 此文為博主原創題解，轉載時請通知博主，並把原文鏈接放在正文醒目位置。 題目鏈接：https://www.luogu.org/problem/show?pid=1835 題目描述 給定區間[L，

luogu P1809 過河問題_NOI導刊2011提高（01）

-m iostream style 人才 三次 nbsp code mat 問題 題目描述 有一個大晴天，Oliver與同學們一共N人出遊，他們走到一條河的東岸邊，想要過河到西岸。而東岸邊有一條小船。 船太小了，一次只能乘坐兩人。每個人都有一個渡河時間T，船劃到對

[luoguP1835] 素數密度_NOI導刊2011提高（04）（素數篩）

[1] targe .org get can clas div http ret 傳送門 數據辣麽大，怎麽搞？（L≤R≤2147483647） 註意到R-L≤1000000 所以可以直接篩R-L區間內的數， 但是需要用已知的小的素數篩， R

P1835 素數密度_NOI導刊2011提高（04）

bsp bre 輸入輸出 long long 輸入輸出格式 void span rim init 題目描述 給定區間[L，R](L≤R≤2147483647,R-L≤1000000)，請計算區間中素數的個數。 輸入輸出格式 輸入格式： 兩個數

【洛谷P1801】黑匣子_NOI導刊2010提高（06）

push 例如 while str logs return 處理 ges 用兩個 題目描述 Black Box是一種原始的數據庫。它可以儲存一個整數數組，還有一個特別的變量i。最開始的時候Black Box是空的．而i等於0。這個Black Box要處理一串命令。 命令只有

洛谷 P1765 手機_NOI導刊2010普及（10） 題解

names 超過 換行符 指定 size main 輸入輸出格式 必須 位置 此文為博主原創題解，轉載時請通知博主，並把原文鏈接放在正文醒目位置。 題目鏈接：https://www.luogu.org/problem/show?pid=1765 題目描述 一般的手

P1807 最長路_NOI導刊2010提高（07）

接下來 for pac ext 輸入輸出 etc while out string 洛谷——P1807 最長路_NOI導刊2010提高（07） 題目描述 設G為有n個頂點的有向無環圖，G中各頂點的編號為1到n，且當為G中的一條邊時有i <

luoguP1774 最接近神的人_NOI導刊2010提高（02）x

event using 現在 class 開啟 str int 圖案 cout P1774 最接近神的人_NOI導刊2010提高（02） 題目描述 破解了符文之語，小FF開啟了通往地下的道路。當他走到最底層時，發現正前方有一扇巨石門，門上雕刻著一幅古代人進行某種活動的圖

P1796 湯姆斯的天堂夢_NOI導刊2010提高（05）

load return 每天 col names bsp 輸出格式 .org i++ 題目描述 湯姆斯生活在一個等級為0的星球上。那裏的環境極其惡劣，每天12小時的工作和成堆的垃圾讓人忍無可忍。他向往著等級為N的星球上天堂般的生活。 有一些航班將人從低等級的星球送上高一

[luoguP1773] 符文之語_NOI導刊2010提高（02）（DP）

strlen problem size ret ems scan sum ++ href 傳送門 f[i][j]表示前i個數余數為j的最優解 sum[i][j]表示字符串i~j所構成的數 #include <cstdio> #includ

小明搬家_NOI導刊2010提高（05）

span long i++ 高效 效率 algorithm using 分鐘 %d 題目描述 小明要搬家了，大家都來幫忙。 小明現在住在第N樓，總共K個人要把X個大箱子搬上N樓。 最開始X個箱子都在1樓，但是經過一段混亂的搬運已經亂掉了。最後大家發現這樣混亂地搬運過程效率

luogu p1799 數列_NOI導刊2010提高（06）

tps else return include .org 沒有 個數 ble 提高 原題鏈接 https://www.luogu.org/problem/show?pid=1799 我一開始覺得這個題真是玄學，直到我發現自己沒有寫max之後。。。（逃） f[i][j]表

P1774 最接近神的人_NOI導刊2010提高（02）

lld 最小 sample clu ++ 輸入輸出格式 ace orange ons 題目描述 破解了符文之語，小FF開啟了通往地下的道路。當他走到最底層時，發現正前方有一扇巨石門，門上雕刻著一幅古代人進行某種活動的圖案。而石門上方用古代文寫著“神的殿堂”。小FF猜想裏面應

P1765 手機_NOI導刊2010普及（10）

讀取 以及 get 換行符 TP tps CI HR 回車 https://www.luogu.org/problemnew/show/P1765 題目描述 一般的手機的鍵盤是這樣的： 1 2 abc 3 def 4 ghi 5 jkl 6 mno 7 pqrs 8 tuv

洛谷 P1777 幫助_NOI導刊2010提高（03） 解題報告

ems 混亂 取出 ring ++ 數據 inline 決定 memset P1777 幫助_NOI導刊2010提高（03） 題目描述 Bubu的書架亂成一團了！幫他一下吧！ 他的書架上一共有n本書。我們定義混亂值是連續相同高度書本的段數。例如，如果書的高度是30，30，3

P1951 收費站_NOI導刊2009提高（2）

二分答案+dijkstra 這道題有被改編的另一道題：“通往奧格瑞瑪的道路”，相信你也做過吧。。。 看到“交的費用中最多的一次最少是多少”，就應該想到二分答案了。 所以我們二分費用，判斷最多的費用是一個\(mid\)的時候可不可以成功到達終點。 如何判斷能否成功到達終點？ 不要說用SPFA！因為……

P1771 方程的解_NOI導刊2010提高（01）

P1771 方程的解_NOI導刊2010提高（01） 按題意用快速冪把$g(x)$求出來 發現這不就是個組合數入門題嗎！ $k$個人分$g(x)$個蘋果，每人最少分$1$個，有幾種方法？ 根據插板法，顯然答案為$C(g(x)-1,k-1)$ 藍後寫個高精度。（我曾經十分天真地認為$ans<=1