小陈的开学第七周程序

一、Atcoder

1.Walk on Multiplication Table

题意：

Takahashi is standing on a multiplication table with infinitely many rows and columns.

The square (i,j) contains the integer i×j. Initially, Takahashi is standing at (1,1).

In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).

Given an integer N, find the minimum number of moves needed to reach a square that contains N.

2≤N≤10^12
N is an integer.

输入：

Input is given from Standard Input in the following format:N

输出：

Print the minimum number of moves needed to reach a square that contains the integer N.

样例输入：

10

样例输出：

5

(2,5) can be reached in five moves. We cannot reach a square that contains 10 in less than five moves.

解题思路：

就是问你几步能走到对应的位置，刚开始我看数据有点大，所以就不太敢写，后来发现只要开根号求解就可以了。

程序代码：

#include<bits/stdc++.h>
using namespace std;
long long n,m,t;
int main(){
   
	scanf("%lld",&n);
	m=sqrt(n);
	if(m*m==n){
   
		cout<<2*m-2<<endl;
		return 0;
	}else{
   
		for(int i=m;i>=1;i--){
   
			t=n/i;
			if(t*i==n){
   
				cout<<i+t-2<<endl;
				break;
			}
		}
	}
	return 0;
}

二、PTA

1.链式表的按序号查找

题意：

本题要求实现一个函数，找到并返回链式表的第K个元素。

L是给定单链表，函数FindKth要返回链式表的第K个元素。如果该元素不存在，则返回ERROR

裁判测试程序样例：

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

#define ERROR -1
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
   
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode List;

List Read(); /* 细节在此不表 */

ElementType FindKth( List L, int K );

int main()
{
   
    int N, K;
    ElementType X;
    List L = Read();
    scanf("%d", &N);
    while ( N-- ) {
   
        scanf("%d", &K);
        X = FindKth(L, K);
        if ( X!= ERROR )
            printf("%d ", X);
        else
            printf("NA ");
    }
    return 0;
}

/* 你的代码将被嵌在这里 */

样例输入：

1 3 4 5 2 -1
6
3 6 1 5 4 2

样例输出：

4 NA 1 2 5 3 

程序代码：

ElementType FindKth(List L,int K){
   
	List p=L;
	while(--K){
   
		if(!p)
			return ERROR;
		p=p->Next;
	}
	if(p)
		return p->Data;
	return ERROR;
}

2.带头结点的链式表操作集

题意：

本题要求实现带头结点的链式表操作集。

各个操作函数的定义为：

List MakeEmpty()：创建并返回一个空的线性表；

Position Find( List L, ElementType X )：返回线性表中X的位置。若找不到则返回ERROR；

bool Insert( List L, ElementType X, Position P )：将X插入在位置P指向的结点之前，返回true。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回false；

bool Delete( List L, Position P )：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回false。

裁判测试程序样例：

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

#define ERROR NULL
typedef enum {
   false, true} bool;
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
   
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

List MakeEmpty(); 
Position Find( List L, ElementType X );
bool Insert( List L, ElementType X, Position P );
bool Delete( List L, Position P );

int main()
{
   
    List L;
    ElementType X;
    Position P;
    int N;
    bool flag;

    L = MakeEmpty();
    scanf("%d", &N);
    while ( N-- ) {
   
        scanf("%d", &X);
        flag = Insert(L, X, L->Next);
        if ( flag==false ) printf("Wrong Answer\n");
    }
    scanf("%d", &N);
    while ( N-- ) {
   
        scanf("%d", &X);
        P = Find(L, X);
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else {
   
            flag = Delete(L, P);
            printf("%d is found and deleted.\n", X);
            if ( flag==false )
                printf("Wrong Answer.\n");
        }
    }
    flag = Insert(L, X, NULL);
    if ( flag==false ) printf("Wrong Answer\n");
    else
        printf("%d is inserted as the last element.\n", X);
    P = (Position)malloc(sizeof(struct LNode));
    flag = Insert(L, X, P);
    if ( flag==true ) printf("Wrong Answer\n");
    flag = Delete(L, P);
    if ( flag==true ) printf("Wrong Answer\n");
    for ( P=L->Next; P; P = P->Next ) printf("%d ", P->Data);
    return 0;
}
/* 你的代码将被嵌在这里 */

样例输入：

6
12 2 4 87 10 2
4
2 12 87 5

样例输出：

2 is found and deleted.
12 is found and deleted.
87 is found and deleted.
Finding Error: 5 is not in.
5 is inserted as the last element.
Wrong Position for Insertion
Wrong Position for Deletion
10 4 2 5 

程序代码：

List MakeEmpty(){
   
	List L;
	L = (Position)malloc(sizeof(struct LNode));
	L->Next=NULL;
	return L;
}
Position Find( List L, ElementType X ){
   
	if(L->Next==NULL)
		return ERROR;
	List p=L->Next;
	while(p){
   
		if(p->Data==X){
   
			return p;
		}
		if(p->Next==NULL){
   
			return ERROR;
		}
		p=p->Next;
	}
//	return ERROR;
}
bool Insert(List L,ElementType X,Position P ){
   
	if(L->Next==NULL){
   
		List s;
		s=(Position)malloc(sizeof(struct LNode));
		s->Data=X;
		s->Next=NULL;
		L->Next=s;
		return true;
	}
	List p=L->Next;
	List p1=L;
	while(p){
   
		if(p==P){
   
			List s;
			s=(Position)malloc(sizeof(struct LNode));
			s->Data=X;
			s->Next=p;
			p1->Next=s;
			return true;
		}
		if(p->Next==NULL){
   
			if(p->Next==P){
   
				List s;
				s=(Position)malloc(sizeof(struct LNode));
				s->Data=X;
				s->Next=NULL;
				p->Next=s;
				return true;
			}else{
   
				printf("Wrong Position for Insertion\n");
				return false;
			}
		}
		p=p->Next;
		p1=p1->Next;
	}
//	printf("Wrong Position for Insertion\n");
//	return false;
}
bool Delete( List L, Position P ){
   
	if(L->Next==NULL){
   
		printf("Wrong Position for Deletion\n");
		return false;
	}
	List p=L->Next;
	List p1=L;
	while(p){
   
		if(p==P){
   
			p1->Next=p->Next;
			return true;
		}
		if(p->Next==NULL){
   
			printf("Wrong Position for Deletion\n");
			return false;
		}
		p=p->Next;
		p1=p1->Next;
	}
//	printf("Wrong Position for Deletion\n");
//	return false;
}

3.递增的整数序列链表的插入

题意：

本题要求实现一个函数，在递增的整数序列链表（带头结点）中插入一个新整数，并保持该序列的有序性。

L是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Insert要将X插入L，并保持该序列的有序性，返回插入后的链表头指针。

裁判测试程序样例：

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

typedef int ElementType;