是的，我这么想，不过新建数组存储mark空间就太浪费了，直接在原数组取模会节省空间一下。

我的代码：
第一题：

//file name: mcstr.c
//feature: get the max common substring from two strings;
//author: wushujie
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define LISTARR_MAX 127 //the length of listarr;

typedef struct list_t list_t; //list made of node_t;
typedef struct node_t node_t; //node;
typedef struct maxstr_t maxstr_t; //information of max common string;
struct list_t{
    node_t *head; //head point to list;
};
struct node_t{
    char *pstr; //point to the proper character of str1;
    node_t *next; //point to the next node;
};
struct maxstr_t{
    int len;
    //len: length of max common string;
    char *str; //point to where the common max string from in str1;
};

#define LISTARR_HASH(x) ((x)-'\0') //get the correct position of listarr;
int preproc(char *str, list_t listarr[]);
int getmaxcom(char *str, list_t listarr[], maxstr_t *pmaxstr);
int listarr_init(list_t listarr[]);
int listarr_destroy(list_t listarr[]);
node_t *list_insert(list_t *list, node_t *pnode);
node_t *make_node(char *str);
//=======================================================

int main(int argc, char *argv[])
{
    if(argc != 3){
        fprintf(stderr, "arguments error!\n"
                "usage:\n"
                "    ./mcstr strings1 strings2\n");
        exit(1);
    }

    list_t listarr[LISTARR_MAX];
    maxstr_t maxstr = {0, argv[1]};

    listarr_init(listarr);
    preproc(argv[1], listarr);
    getmaxcom(argv[2], listarr, &maxstr);
    listarr_destroy(listarr);

    maxstr.str[maxstr.len] = '\0';
    fprintf(stdout, "%d  \"%s\"\n", maxstr.len, maxstr.str);

    return 0;
}

int preproc(char *str, list_t listarr[])
{
    while(str[0] != '\0'){
        list_insert( &listarr[LISTARR_HASH(str[0])],
                make_node(&str[0]));
        str++;
    }

    return 0;
}

int getmaxcom(char *str, list_t listarr[], maxstr_t *pmaxstr)
{
    node_t *curnd = NULL;
    int laloc = 0,
        i = 0;
    //traverse_str(str);
    while(str[0] != '\0'){
        laloc = LISTARR_HASH(str[0]);
            //traverse_list(listarr[loc]);
            for(curnd=listarr[laloc].head;
                    curnd != NULL; curnd = curnd->next){
                //compare(str, curnd->pstr);
                for(i=0; str[i] != '\0' && str[i]==curnd->pstr[i]; i++);
                if(i > pmaxstr->len){
                    pmaxstr->len = i;
                    pmaxstr->str = &str[0];
                }
            }
        str++;
    }

    return 0;
}

int listarr_init(list_t listarr[])
{
    int i;
    for(i=0; i<LISTARR_MAX; i++){
        listarr[i].head = NULL;
    }

    return 0;
}

int listarr_destroy(list_t listarr[])
{
    node_t *curnd, *next;
    int i;
    for(i=0; i<LISTARR_MAX; i++){
        curnd = listarr[i].head;
        while(curnd != NULL){
            next = curnd->next;
            free(curnd);
            curnd = next;
        }
    }

    return 0;
}

node_t *list_insert(list_t *list, node_t *pnode)
{
    pnode->next = list->head;
    list->head = pnode;

    return pnode;
}

node_t *make_node(char *str)
{
    node_t *pnode = malloc(sizeof(node_t));
    if(pnode == NULL){
        fprintf(stderr, "no memory!");
        exit(2);
    }

    pnode->pstr = str;
    pnode->next = NULL;

    return pnode;
}

第二题：

//file name:search_same.c
#include <stdio.h>

int search_same(int arr[], int n);

int main()
{
    int arr[100];
    int i;

    for(i=0; i<100; i++){
        arr[i] = 100 - i;
    }
    arr[0] = 0;
    arr[34] = 23;

    fprintf(stdout, "The same one:%d\n", search_same(arr, 100));

    return 0;
}

int search_same(int arr[], int n)
{
    int i, value;
    for(i=0; i<n; i++){
        value = arr[i]%n;
        if(arr[value]>=n){
            return value;
        }else{
            arr[value] += n;
        }
    }

    return -1;
}

[ 本帖最后由 wsj3000 于 2010-5-2 19:59 编辑 ]

楼主 你忽悠我~~~~
其实就将就我刚才的代码改下就可以了
思路：
题目要求只输入100个数，我假设题目可以要求输入101个数，那么0-99个数就都可以被选一次，那么就刚才的代码就可以改下了就出结果
#include <stdio.h>
#include <stdlib.h>

/*
假设有101个数，且从0-99全部都取到了，则和为4950 + number（重复的数）
*/
int main( void )
{
    int temp;
    int array[101];
   
    for( temp = 0; temp < 100; temp++ )
    {
         array[temp] = temp;
    }
    printf( "输入你指定相同的数：" );
    scanf( "%d", &array[100] );
   
    int Number = 0;
   
    for( temp = 0; temp < 101; temp++ )
    {
         Number = Number + array[temp];
    }
    printf( "相同的数为：%d", Number % 4950 );
    return 0;
}

是arr[100]中存了0-99个数，其中数字a不在里面，数字b出现的两次，要求求b。不是那么容易吧？主要是开始的时候，a，b你都不知道谁呀。
你上面假设a在里面是不对的。

[ 本帖最后由 wsj3000 于 2010-5-1 22:01 编辑 ]

题目读错了~~~我还以为是在0<a<99里面取数呢   啊  臭大了

楼主 头被你弄晕了~~~你是不是array【100】里面存了100个数，然后这100个数是从0-99里面选，是不是嘛，如果是的话 就没错

是arr[100]中存了0-99个数，其中数字a不在里面，数字b出现的两次，要求求b。不是那么容易吧？主要是开始的时候，a，b你都不知道谁呀。
你上面假设a在里面是不对的。


我是不知道a和b是谁，但是我假设是一个101长的数组，根据你题目，100个数中，有98个不同，那么还剩2个数没选到，这里我把数组长度增加到101，那么就还有3个空间来存放数字对不对，我假设a是其中出现2次的那个数，那么还剩一个的数是一次都没有出现的那个数；
那么这101个数中，我保证了0-99之间，每个数都被选中了一次，那么101个数的和肯定是4950 + number（重复的数），我说得够清楚了
不信 你运行程序 自己试，实践出真理嘛   哈哈

汗～～～，这样吧,举个例子：
假设0-99中， 23不存在，位置被24代替，也就是说，0个23，2个24，其他数字都是1个，请问怎么算出来是24。
按照你的方法数组变成101个， 然后这样算， 数组和 - 4950 = 所求数；
事实上，101数组和 你是没法求出来的，因为给你的只有100个元素，而且你不知道地101个元素该取哪个。

这样吧 我把题目给你改下  
有个数组arr[100]存放了101个数,这101个数取自0-99,且只有两个相同的数,剩下的99个数不同（且数组最后一个数不能是出现2次的那个数）,写一个搜索算法找出相 同的那个数的值.

这个题目和你那个题目一样