NEFU锐格 算法设计与分析第二章 递归与分治

递归与分治实验一

6104

#include <iostream>
using namespace std;


int max(int a,int b)
{
    return (a>b)?a:b;
}

int MaxElement(int a[],int l,int r)
{
    int max1=0;
    int max2=0;
    if(l==r)
        return a[l];
    if(l==r-1)
        return max(a[l],a[r]);
    else
    {
        int mid=(l+r)/2;
        max1=MaxElement(a,l,mid);
        max2=MaxElement(a,mid+1,r);
        return max(max1,max2);
    }
    
}
int main()
{
    int a[1000];
    int n;
    scanf("%d", &n);
    for(int i=0;i<n;i++)
    {
    	scanf("%d", &a[i]);
    }
    int num;
    num=MaxElement(a,0,n-1);
    cout<<num;
    return 0;
}

6103

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

void Merge(int a[],int b[],int l,int mid,int r)
{
	int i=l;
	int j=mid+1;
	int k=l;
	while(i!=mid+1 && j!=r+1)
	{
		if(a[i]>a[j])
			b[k++]=a[j++];
		else
			b[k++]=a[i++];
		
	}
	while (i!=mid+1)
	{
		b[k++]=a[i++];
	}
	while(j!=r+1)
	{
		b[k++]=a[j++];
	}
	for(i=l;i<=r;i++)
	{
		a[i]=b[i];
	}

}

void MergeSort(int a[],int b[],int l,int r)
{
	int mid;
	if(l<r)
	{
		mid=(l+r)/2;
		MergeSort(a,b,l,mid);
		MergeSort(a,b,mid+1,r);
		Merge(a,b,l,mid,r);
	}
}

int main()
{
	int a[1000];
	int n;
	int i;
	scanf("%d", &n);
	for(i=0;i<n;i++)
	{
		scanf("%d", &a[i]);
	}
	int b[1000];
	MergeSort(a,b,0,n-1);
	for(i=0;i<n;i++)
	{
		printf("%d ",a[i]);
	}
	printf("\n");
	return 0;

}

6102

#include <iostream>
#include <cstring>
using namespace std;
int tile=1;
int Board[100][100];

/*
 * tr : 棋盘左上角格子的行号
 * tc : 棋盘左上角格子的列号
 * dr : 特殊方格左上角顶点的行号
 * dc特殊方格左上角顶点的列号
 * size ：棋盘规格 n*n
 * title: 骨牌的型号
 */
void ChessBoard(int tr,int tc,int dr,int dc,int size) 
{
	if(size==1)
	    return;
	int t=tile++;
	int s=size/2;
	if(dr<tr+s&&dc<tc+s)            //特殊方格位于左上角的棋盘时
        ChessBoard(tr,tc,dr,dc,s);   //对左上角棋盘继续进行递归划分覆盖
	else                           
	{
		Board[tr+s-1][tc+s-1]=t;    //将t号L型骨牌覆盖当前子棋盘右下角的方格
		ChessBoard(tr,tc,tr+s-1,tc+s-1,s);   //对左上角棋盘继续进行递归划分覆盖
	}
	if(dr<tr+s&&dc>=tc+s)                          //覆盖右上角棋盘
	    ChessBoard(tr,tc+s,dr,dc,s);              //对右上角棋盘继续进行递归划分覆盖
	else
	{
		Board[tr+s-1][tc+s]=t;               //将t号L型骨牌覆盖当前子棋盘左下角的方格
		ChessBoard(tr,tc+s,tr+s-1,tc+s,s);       //对右上角棋盘继续进行递归划分覆盖
	}
	if(dr>=tr+s&&dc<tc+s)                          //特殊方格位于左下角的棋盘时
	    ChessBoard(tr+s,tc,dr,dc,s);              //对左下角棋盘继续进行递归划分覆盖
	else
	{
		Board[tr+s][tc+s-1]=t;               //将t号L型骨牌覆盖当前子棋盘左下角的方格
		ChessBoard(tr+s,tc,tr+s,tc+s-1,s);       //对右上角棋盘继续进行递归划分覆盖
	}
	if(dr>=tr+s&&dc>=tc+s)                          //特殊方格位于右下角的棋盘时
	    ChessBoard(tr+s,tc+s,dr,dc,s);              //对右下角棋盘继续进行递归划分覆盖
	else
	{
		Board[tr+s][tc+s]=t;                        //将t号L型骨牌覆盖当前子棋盘左上角的方格
		ChessBoard(tr+s,tc+s,tr+s,tc+s,s);       //对右下角棋盘继续进行递归划分覆盖
	}	
}
int main()
{
   int size,x,y;
   cin>>size;
   cin>>x>>y;
   memset(Board,0,sizeof(Board));
   ChessBoard(1,1,x,y,size);
   for(int i=1;i<=size;i++)
   {
	   for(int j=1;j<=size;j++)
	        printf("%2d ",Board[i][j]);
		cout<<endl;
   }
  
   return 0;
}