DMA占用内存时CPU不可占用
目录：
1.DMA方式特点
2.DMA接口的功能和组成
3.DMA的工作过程
4.DMA接口的类型

bool is_two() {
	queue<int> que;
	que.push(1);
	int from;
	visit[1]=1;
	while(!que.empty()) {
		from=que.front();
		que.pop();
		int i=1;
		for(i; i<=n; i++) {
			if(map[from][i]) {
				if(!visit[i]) {
					que.push(i);
					visit[i]=(visit[from]&1)+1;
				} else if(visit[i]==visit[from]) {
					return false;
				}
			}
		}
	}
	return true;
}
```  
匈牙利算法主要是解决是二分图匹配问题。  
一个顶点可以与多个结点相连。如果一个顶点只连接一个顶点求最多可以连接多少。  
假如 a可以和c,d,e,f相连，h可以和c,d,m,n,  z可以和c,d,k相连。
首先先匹配a和c。  
第二步是匹配h，h不能喝c匹配，但是h并不想换人，所以就返回去看a能不能换a没办法只能换一个换到了d，h匹配到了c。最后就是z了，他也想匹配c，可是他也不想换，只能h换了，h换成了d可是d又和a匹配了，h也不想换之后a换了，a最后换成了e。最后a，h，z都匹配好了。  
当然这个换人的过程是用递归实现的。  

以下是题目:  
[hdu2444](http://acm.hdu.edu.cn/showproblem.php?pid=2444)   
这道题先要判断是否为二分图，否的话输出-1  



    
  
  	   

#include<iostream>
#include<unordered_map>
#include<algorithm>
#include<cmath>
#include<queue>
#include<cstring>
#include<vector>
#define fastc cin.tie(NULL);
#define fasto cout.tie(NULL);
#define fasts ios::sync_with_stdio(false);
#define END return 0;
#include<iomanip>

using namespace std;
//char num[1000];

int value[101][101];//记录值进行dp
int visit[101];//看是否访问过，避免重复查找。
int rec[101][101];//记录地图
typedef pair<int,int> P;//储存bugs和brains
P pa[101];

int n,m;


void dp(int u) {
	visit[u]=1;
	int cost=(pa[u].first+19)/20;
	for(int i=m; i>=cost; i--) {
		value[u][i]=pa[u].second;//在第u层花费了cost个士兵都可以获得所有的brain
	}
	for(int i=1; i<=n; i++) {
		if(rec[u][i] && !visit[i]) {
			dp(i);
			for(int j=m; j>=cost; j--) {
				int rest=j-cost;
				for(int k=1; k<=rest; k++) {
					value[u][j]=max(value[u][j],value[i][k]+value[u][j-k]);
				}
			}
		}
	}
}

void prin() {
	for(int i=0; i<=n; i++) {
		for(int j=0; j<=m; j++) {
			cout<<value[i][j]<<" ";
		}
	cout<<endl;
	}
	//cout<<endl;
}


int main() {
	fastc fasto fasts
	while(cin>>n>>m) {
		if(n==m&&n==-1) break;
		memset(value,0,sizeof(value));
		memset(visit,0,sizeof(visit));
		memset(pa,0,sizeof(pa));
		memset(rec,0,sizeof(rec));
		int i=1;
		for(i; i<=n; i++) {
			cin>>pa[i].first>>pa[i].second;
		}
		int one,two;
		for(i=1; i<n; i++) {
			cin>>one>>two;
			rec[one][two]=1;
			rec[two][one]=1;
		}
		dp(1);
		prin();
		cout<<value[1][m]<<endl;
	}
	END
}

<dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.5.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.5.0</version>
        </dependency>

package com.ctgu.upndo.controller;


import com.ctgu.upndo.pojo.Member;
import com.ctgu.upndo.pojo.Submit;
import com.ctgu.upndo.pojo.Task;
import com.ctgu.upndo.propeties.propeties;
import com.ctgu.upndo.service.SaveAndFlushService;
import com.ctgu.upndo.service.SearchService;
import com.ctgu.upndo.utils.CodeEnum;
import com.ctgu.upndo.utils.GetWayRan;
import com.ctgu.upndo.utils.Result;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.awt.print.Pageable;
import java.io.File;

@RestController
@RequestMapping("/upload")
public class UploadController {
    @Autowired
    propeties filepath;
    @Autowired
    SearchService searchService;
    @Autowired
    SaveAndFlushService saveAndFlushService;
@ApiOperation(value="上传")
@ApiImplicitParams({
        @ApiImplicitParam(name="file",value="前端文件，只有一个"),
        @ApiImplicitParam(name="submit",value = "提交详细Submit对象")
})
    @RequestMapping("/one")
    public Result<Integer> upload( @RequestParam("file") MultipartFile file, @RequestParam("submit") Submit submit) {
        Result<Integer> res = new Result<>();
        try {
            if (file.isEmpty()) {
                res.setResult("文件是空的啊..");
                return res;
            }
            String fileName = file.getOriginalFilename();
            String suffixName = fileName.substring(fileName.lastIndexOf("."));
            if (suffixName != "zip" && suffixName!="rar") {
                res.setResult("30008","文件必须是zip和rar的啊,你的怎么是" + suffixName + "的啊");
                return res;
            }
            Result<Member> rm = searchService.findMemberByTidAndUid(submit.getTid(), submit.getSid());
            if(rm.getData()==null){
                res.setResult(CodeEnum.UPLOAD_ERROR);
                return res;
            }
            Member member=rm.getData();
            Integer times = rm.getData().getTimes();
            times++;
            Integer ta = submit.getTid();
            member.setTimes(times);
            String ran= GetWayRan.getUpLoadRandom();
            String path = filepath.getUpload_path()+ta.toString()+File.separator+ran+suffixName;
            submit.setWay(path);
            member.setLast(path);
            File fi = new File(path);
            if (!fi.getParentFile().exists()) {
                fi.getParentFile().mkdir();
            }
            if (times == 1) {
                Result<Task> rt = searchService.findTaskByTid(submit.getTid());
                Task task=rt.getData();
                Integer number = task.getFinish();
                number++;
                task.setFinish(number);
                saveAndFlushService.SaveAndFlushTask(task);
            }
            file.transferTo(fi);
            saveAndFlushService.SaveSubmit(submit);
            saveAndFlushService.SaveAndFlushMember(member);
        } catch (Exception e) {
            res.setResult(CodeEnum.UPLOAD_ERROR);
        }
        res.setResult(CodeEnum.UPDATE_SUCCESS);
        return res;
    }

}

package com.ctgu.upndo.controller;

import com.ctgu.upndo.pojo.Submit;
import com.ctgu.upndo.service.SearchService;
import com.ctgu.upndo.utils.CodeEnum;
import com.ctgu.upndo.utils.GetNumber;
import com.ctgu.upndo.utils.Result;
import com.ctgu.upndo.utils.ToNumber;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.List;

@RestController
@RequestMapping("/download")
public class DownloadController {

    @Autowired
    SearchService searchService;
@ApiOperation(value="下载")
@ApiImplicitParam(name="list",value="String对象，下载项目序号")
    @RequestMapping(value = "student")
    public Result<Integer> upload(HttpServletRequest request, HttpServletResponse response,@RequestParam(value = "path") String path,@RequestParam(value = "judge") String judge){
        Result<Integer> res=new Result<>();
        Integer flag= ToNumber.getNumber(judge);
        if(flag==0){
            res.setResult("30013","未在时限内，不可下载");
        }
        res.setResult(CodeEnum.DOWNLOAD_SUCCESS);
        String status=null;
        String fileName=new String();
        BufferedInputStream bis = null;
        try{
            File file=new File(path);
            if(!file.exists()){
                res.setResult("30012","文件为空");
                return res;
            }
            fileName=file.getName();
            response.setContentType("application/force-download");// 设置强制下载不打开
            response.addHeader("Content-Disposition", "attachment;fileName=" + fileName);// 设置文件名
            byte[] buffer=new byte[1024];
            bis=new BufferedInputStream(new FileInputStream(file));
            OutputStream os=response.getOutputStream();
            int number=bis.read(buffer);
            while(number!=-1){
                os.write(buffer,0,number);
                number=bis.read(buffer);
            }
        }catch(Exception e){
            res.setResult(CodeEnum.DOWNLOAD_ERROR);
        }

        return res;
    }

}

package com.ctgu.upndo.controller;


import com.ctgu.upndo.mapper.MemberMapper;
import com.ctgu.upndo.mapper.TaskMapper;
import com.ctgu.upndo.pojo.Member;
import com.ctgu.upndo.pojo.Task;
import com.ctgu.upndo.utils.CodeEnum;
import com.ctgu.upndo.utils.GetNumber;
import com.ctgu.upndo.utils.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.HttpURLConnection;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

@RequestMapping(value = "/downloads")
public class Download {
    @Autowired
    MemberMapper memberMapper;
    @Autowired
    TaskMapper taskMapper;

    public Result<Integer> downloads(HttpServletResponse res, String list) throws IOException {
        Result<Integer> result = new Result<>();
        List<Integer> numbers = GetNumber.getnumber(list);
        int len = numbers.size();
        List<String> filePaths = new ArrayList<>();
        Member member = new Member();
        //String way = new String();
        for (int i = 0; i < len; i++) {
            member = memberMapper.findMemberById(numbers.get(i));
            filePaths.add(member.getLast());
        }
        Task task = taskMapper.findTaskById(member.getTid());
        String name = task.getTitle();
        result.setResult(CodeEnum.SCCESS);
        try {
            File file = new File(member.getLast());
            String zipBasePath = file.getAbsolutePath();
            String zipName = name + ".zip";
            String zipFilePath = zipBasePath + File.separator + zipName;

            res.setCharacterEncoding("UTF-8"); //设置编码字符
            res.setContentType("application/force-download;charset=UTF-8"); //设置下载内容类型
            OutputStream out = res.getOutputStream();   //创建页面返回方式为输出流，会自动弹出下载框


            File zip = new File(zipFilePath);
            if (!zip.exists()) {
                zip.createNewFile();
            }
            //创建zip文件输出流
            ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zip));
            this.zipFile(zipBasePath, zipName, zipFilePath, filePaths, zos);
            zos.close();
            res.setHeader("Content-disposition", "attachment;filename=" + zipName);//设置下载的压缩文件名称

            //将打包后的文件写到客户端，输出的方法同上，使用缓冲流输出
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(zipFilePath));
            byte[] buff = new byte[bis.available()];
            bis.read(buff);
            bis.close();
            out.write(buff);//输出数据文件
            out.flush();//释放缓存
            out.close();//关闭输出流
        } catch (Exception e) {
            result.setResult(CodeEnum.DOWNLOAD_ERROR);
        }
        return result;
    }

    private String zipFile(String zipBasePath, String zipName, String zipFilePath, List<String> filePaths, ZipOutputStream zos) throws IOException {

        //循环读取文件路径集合，获取每一个文件的路径
        for (String filePath : filePaths) {
            File inputFile = new File(filePath);  //根据文件路径创建文件
            if (inputFile.exists()) { //判断文件是否存在

                    //创建输入流读取文件
                    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(inputFile));

                    //将文件写入zip内，即将文件进行打包
                    zos.putNextEntry(new ZipEntry(inputFile.getName()));

                    //写入文件的方法
                    int size = 0;
                    byte[] buffer = new byte[1024];  //设置读取数据缓存大小
                    while ((size = bis.read(buffer)) > 0) {
                        zos.write(buffer, 0, size);
                    }
                    //关闭输入输出流
                    zos.closeEntry();
                    bis.close();
            }
        }
        return null;
    }
}

这里在开始匹配前记录回文串半径最小值。  
当```mx>i```
很容易我们可以得到``` k=id*2-i```是i 关于id的对称点。而以id为中心
mx-id为半径的字符串是对称的，所以当p[k]的边界在id的边界之内，以下标为i的字符串的半径为p[k]的字符串一定是回文串。而当p[k] 大于id的边界的时候就不能保证对称性了，所以这里就取mx-i。  
当mx < i 这里我们就不能确定对称性了，所以直接取1.
以下是代码:

int *p=(int *)0 ;
cout<<p;