題意

使用一種叫做“run length encoding”的方式來儲存大尺寸圖片，該方法是通過記錄編碼值和編碼長度的對（value，length）來儲存圖片。有一種簡單的edge detection演算法是將影象中的每一個點的值與他周圍的八個點求差，然後取絕對值的最大值。

現在的任務就是實現這個演算法，輸入的圖片是以run length encoding的形式表示的，同時也要求轉換後的圖片也以run length encoding的形式表示。

思路

題意中說明圖片的長度為10^9，因此不可能採用暴力計演算法。但是輸入的pair number不超過1000，數量上是很少的，因此可以採用跳躍編碼。

run length encoding編碼方法是記錄編碼值和該值的編碼長度，這裡長度可以用開始和結束位置代替，結束位置可以用下一個值的開始位置表示。這樣就變成記錄每一個出現的新值和出現的位置即可。

而edge detection中每一個新值的出現都是因為輸入圖片中新值的出現。因此，只要對輸入圖片的每一個pair計算這個新值開始位置周圍8個畫素edge值，並記錄位置即可。然後對所有計算的edge值根據位置排序，並且對edge值相同的pair進行合併就是所求結果。

異常點處理

上述講到對於輸入圖片中每一個新值的周圍8個畫素點都進行計算，但是當該開始位置位於一行的末尾時是否需要對後續畫素計算。答案是需要。

下表中第二行第三列的3是一個新值因此需要對周圍8個畫素計算；而第二行第四列的4也是一個新值，那麼就要對該值周圍的8個畫素，包括其後的三個值（括號裡），而它們對應的畫素就是綠色圈起來的畫素點。

另外一個異常點出現在最後一行，見下圖，這是因為最後一行的第一個畫素因為沒有了下一行而出現變化。

原始碼

#include <iostream>
#include <math.h>
#include <algorithm>
using namespace std;

const int size = 1000;
int width;
int totle; //input
 
 pix length

typedef struct{
    int value;
    int pos;
} Pix;

int in_pairs[size][2];  //input picture, pairs[i][0] is value, pairs[i][1] is run length;
Pix out_pairs[size*8];
int pairs_num = 0;

//pos starts from 0

int get_value(int pos){
    int len=0, i=0;
    while(pos > len-1){
        len += in_pairs[i++][1];
    }
    return in_pairs[i-1][0];
}

int cmp(const void *m, const void *n){
    Pix * a = (Pix *) m;
    Pix * b = (Pix *) n;
    return a->pos - b->pos;
}

int cal_value(int pos){

    int max = 0;
    int value = get_value(pos);

    int row = pos/width;
    int col = pos%width;

    for(int i=row-1;i<row+2;i++){
        for(int j=col-1;j<col+2;j++){

            int tmp_pos = i*width + j;

            if(j<0 || j>=width || i<0 || tmp_pos>=totle)
                continue;

            int tmp_value = get_value(tmp_pos);
            if(abs(value-tmp_value) > max)
                max = abs(value-tmp_value);
        }
    }
    return max;
}

int main(){
    while(cin>>width && width){
        pairs_num = 0;
        totle = 0;

        int val, len;
        while(cin>>val>>len && len){
            in_pairs[pairs_num][0] = val;
            in_pairs[pairs_num++][1] = len;
            totle += len;
        }

        cout << width <<endl;

        int pos = 0;
        int out_index = 0;

        for(int k=0;k<pairs_num;k++){
            int row = pos/width;
            int col = pos%width;

            for(int i=row-1;i<row+2;i++){
                for(int j=col-1;j<col+2;j++){

                    int tmp_pos = i*width + j;
                    //if(j<0 || j>=width || i<0 || tmp_pos>=totle)
                    if(j<0 || i<0 || tmp_pos>=totle)
                        continue;

                    out_pairs[out_index].pos = tmp_pos;
                    out_pairs[out_index++].value = cal_value(tmp_pos);
                }
            }
            pos += in_pairs[k][1];
        }

        //head point in last line
        out_pairs[out_index].pos = totle - width;
        out_pairs[out_index++].value = cal_value(totle - width);

        qsort(out_pairs, out_index, sizeof(Pix), cmp);

        int res_val=-1, start_pos = -1;
        for(int i=0;i<out_index;i++){
            if(out_pairs[i].value == res_val)
                continue;
            else{
                if(res_val < 0){
                    res_val = out_pairs[i].value;
                    start_pos = 0;
                    continue;
                }
                else{
                    cout<<res_val<<" "<<out_pairs[i].pos-start_pos<<endl;
                    res_val = out_pairs[i].value;
                    start_pos = out_pairs[i].pos;
                }
            }
        }
        cout<<res_val<<" "<<totle-start_pos<<endl;
        cout<<"0 0"<<endl;
    }
    cout<<"0";
}