北大poj- 1009

Edge Detection

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 22835		Accepted: 5398

Description

IONU Satellite Imaging, Inc. records and stores very large images using run length encoding. You are to write a program that reads a compressed image, finds the edges in the image, as described below, and outputs another compressed image of the detected edges.
A simple edge detection algorithm sets an output pixel's value to be
the maximum absolute value of the differences between it and all its
surrounding pixels in the input image. Consider the input image below:



The upper left pixel in the output image is the maximum of the
values |15-15|,|15-100|, and |15-100|, which is 85. The pixel in the 4th
row, 2nd column is computed as the maximum of |175-100|, |175-100|,
|175-100|, |175-175|, |175-25|, |175-175|,|175-175|, and |175-25|, which
is 150.

Images contain 2 to 1,000,000,000 (10⁹) pixels. All
images are encoded using run length encoding (RLE). This is a sequence
of pairs, containing pixel value (0-255) and run length (1-10⁹).
Input images have at most 1,000 of these pairs. Successive pairs have
different pixel values. All lines in an image contain the same number of
pixels.

Input

Input
consists of information for one or more images. Each image starts with
the width, in pixels, of each image line. This is followed by the RLE
pairs, one pair per line. A line with 0 0 indicates the end of the data
for that image. An image width of 0 indicates there are no more images
to process. The first image in the example input encodes the 5x7 input
image above.

Output

Output
is a series of edge-detected images, in the same format as the input
images, except that there may be more than 1,000 RLE pairs.

Sample Input

7
15 4
100 15
25 2
175 2
25 5
175 2
25 5
0 0
10
35 500000000
200 500000000
0 0
3
255 1
10 1
255 2
10 1
255 2
10 1
255 1
0 0
0

Sample Output

7
85 5
0 2
85 5
75 10
150 2
75 3
0 2
150 2
0 4
0 0
10
0 499999990
165 20
0 499999990
0 0
3
245 9
0 0
0

Hint

A brute force solution that attempts to compute an output value for every individual pixel will likely fail due to space or time constraints.

Source

Mid-Central USA 2000

 

分析：

英文的题目，有点蛋疼，有几个限制数字理解错了意思，浪费了时间。

注意点：

1. 计算点不是上下左右4个点，而是周围8个点。

2. 每个点与左侧delta是前一个点与右侧的delta，不需要重复计算。

3. 行可以很长很长，注意long。

4. 每组input可以长为1000，而不是256。

5. 处理采用输入一组处理一组，循环处理。

6. 需要采用快进处理：1）多行相同；2）同一行相同数字很多。（考虑了最简单场景）

 

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #define MAX_POINT_SERIES_NUM 1000

 #define FAILURE (int)0xF
 #define SUCCESS (int)0x0

 #define TRUE  (int)1
 #define FALSE (int)0

 #define MIN(a, b) (((a) < (b))?(a):(b))
 #define MAX(a, b) (((a) > (b))?(a):(b))

 typedef int BOOL;

 typedef struct
 {
     int value;
     long long num;
     long long startIdx;
     long long endIdx;
 }PointSeries;

 typedef struct
 {
     long long imageWide;
     int pointsNum;
     long long endIdx;
     PointSeries points[MAX_POINT_SERIES_NUM];
 }Image;

 Image g_input;
 Image g_output;

 int GetInputImage(Image *input)
 {
     int i = ;
     long long idx = ;
     PointSeries *points = NULL;

     scanf("%I64d", &input->imageWide);
     if( == input->imageWide)
     {
         printf("0\n");
         return FAILURE;
     }

     do
     {
         points = &input->points[i];
         scanf("%d %I64d", &points->value, &points->num);
         points->startIdx = idx;
         points->endIdx = idx + points->num - ;
         idx = idx + points->num;
         i++;
     }while(points->num !=  && MAX_POINT_SERIES_NUM <= i);

     input->endIdx = input->points[i-].endIdx;

     input->pointsNum = i;
     return SUCCESS;
 }

 void PrintImage(Image *image)
 {
     int i;
     printf("%I64d\n", image->imageWide);
     for(i = ; i < image->pointsNum; i++)
     {
         printf("%d %I64d\n",
                image->points[i].value,
                image->points[i].num);
     }
     if(image->imageWide != ) printf("0 0\n");
 }

 static int GetLeftDelta(long long wide, PointSeries *points, long long idx, PointSeries *cmpPoints)
 {
     PointSeries *lastPoints = NULL;
     long long lastIdx = idx - ;

     if(idx % wide !=
        && lastIdx >=
        && lastIdx < points->startIdx)
     {
         lastPoints = points-;
         return abs(lastPoints->value - cmpPoints->value);
     }

     return ;
 }

 static int GetRightDelta(Image *input, PointSeries *points, long long idx, PointSeries *cmpPoints)
 {
     PointSeries *nextPoints = NULL;
     long long nextIdx = idx + ;

     if(idx % input->imageWide != input->imageWide -
        && points->endIdx < input->endIdx
        && nextIdx > points->endIdx)
     {
         nextPoints = points+;
         return abs(nextPoints->value - cmpPoints->value);
     }

     return ;
 }

 static int GetPointSeries(long long idx, long long endIdx, PointSeries **targetPoints)
 {
     PointSeries *points = (*targetPoints);
     if(idx <  || idx > endIdx) return FAILURE;

     while()
     {
         if(idx <= points->endIdx && points->startIdx <= idx) break;

         if(idx > points->endIdx)
         {
             points++;
         }
         else if(idx < points->startIdx)
         {
             points--;
         }
     }

     *targetPoints = points;

     return SUCCESS;
 }

 static int GetOtherLineDelta(Image *input, PointSeries *orgPoints, long long idx)
 {
     int leftDelta, rightDelta, delta;
     PointSeries *target = orgPoints;

     if(FAILURE == GetPointSeries(idx, input->endIdx, &target)) return ;

     leftDelta = GetLeftDelta(input->imageWide, target, idx, orgPoints);
     rightDelta = GetRightDelta(input, target, idx, orgPoints);
     delta = abs(target->value - orgPoints->value);

     delta = MAX(delta , leftDelta);
     delta = MAX(delta , rightDelta);

     return delta;
 }

 void SaveOutput(Image *output, int delta, long long num)
 {
     PointSeries *points = &output->points[output->pointsNum];

     if(num == ) return;

     if(output->pointsNum == )
     {
         points->num = num;
         points->value = delta;
         output->pointsNum = ;
         return;
     }

     if((points-)->value != delta)
     {
         points->num = num;
         points->value = delta;
         output->pointsNum++;
     }
     else
     {
         (points-)->num += num;
     }
 }

 void ProcPoints(Image *input, PointSeries *points, long long num, int *rightDelta, long long *idx, Image *output)
 {
     long long j;
     long long tmpIdx = *idx;
     int leftDelta, upDelta, dowmDelta, delta;
     int tmpRight = *rightDelta;

     for(j = ; j < num; j++)
     {
         leftDelta = tmpRight;
         tmpRight = GetRightDelta(input, points, tmpIdx, points);
         upDelta = GetOtherLineDelta(input, points, tmpIdx - input->imageWide);
         dowmDelta = GetOtherLineDelta(input, points, tmpIdx + input->imageWide);
         delta = MAX(leftDelta, tmpRight);
         delta = MAX(delta, upDelta);
         delta = MAX(delta, dowmDelta);
         SaveOutput(output, delta, );
         tmpIdx++;
     }
     *idx = tmpIdx;
     *rightDelta = tmpRight;
 }

 void RowFastForward(Image *input, PointSeries *points, int *rightDelta, long long *idx, Image *output)
 {
     long long firstNum, secondNum, thridNum;
     long long endIdx;
     long long wide = input->imageWide;

     if(*idx % wide == )
         firstNum = wide;
     else
         firstNum = wide + ;

     ProcPoints(input, points, firstNum, rightDelta, idx, output);

     if(points->endIdx % wide == wide - )
         endIdx = points->endIdx - wide;
     else
         endIdx = points->endIdx - wide - ;

     secondNum = endIdx +  - points->startIdx - firstNum;
     thridNum = points->endIdx - endIdx;

     SaveOutput(output, , secondNum);
     *idx += secondNum;

     ProcPoints(input, points, thridNum, rightDelta, idx, output);
 }

 inline BOOL CanBeRowFastForward(long long pointsNum, long long imageWide)
 {
     if(pointsNum >=  * imageWide - )
     {
         return TRUE;
     }
     else
     {
         return FALSE;
     }
 }

 inline BOOL CanBeSpecFastForward(PointSeries *points, long long wide)
 {
     if(points->num ==
        || points->num / wide ==
        || points->num % wide !=
        || (points+)->num % wide != )
     {
         return FALSE;
     }
     return TRUE;
 }

 void SpecFastForward(PointSeries *points, long long wide, int *specDelta, Image *output)
 {
     int tmpDeta = *specDelta;
     long long num, lineNum = points->num / wide;

     num = (lineNum > ) ? wide : ;

     SaveOutput(output, tmpDeta, num);

     num = (lineNum > ) ? ((lineNum - )*wide) : ;

     SaveOutput(output, , num);

     if((points+)->num !=  && lineNum == )
     {
         tmpDeta = MAX(abs(points->value - (points+)->value), tmpDeta);
     }
     else if((points+)->num !=  && lineNum > )
     {
         tmpDeta = abs(points->value - (points+)->value);
     }
     else if((points+)->num ==  && lineNum > )
     {
         tmpDeta = ;
     }

     SaveOutput(output, tmpDeta, wide);

     *specDelta = tmpDeta;
 }

 void ProcImage(Image *input, Image *output)
 {
     long long i = , idx = ;
     int rightDelta = ;
     int specDelta = ;
     PointSeries *points = &input->points[];

     if(input->pointsNum == ) return;

     while(CanBeSpecFastForward(points, input->imageWide))
     {
         SpecFastForward(points, input->imageWide, &specDelta, output);
         points++;
         i++;
     }

     for(; i < input->pointsNum; i++)
     {
         points = &input->points[i];

         if(points->num <= ) continue;

         if(CanBeRowFastForward(points->num, input->imageWide))
         {
             RowFastForward(input, points, &rightDelta, &idx, output);
         }
         else
         {
             ProcPoints(input, points, points->num, &rightDelta, &idx, output);
         }
     }
 }

 inline void InitOutputBuf(Image *input, Image *output)
 {
     output->pointsNum = ;
     output->imageWide = input->imageWide;
 }

 int main()
 {
     while(SUCCESS == GetInputImage(&g_input))
     {
         InitOutputBuf(&g_input, &g_output);
         ProcImage(&g_input, &g_output);
         PrintImage(&g_output);
     }

     return ;
 }