浙江大学 算法和程序设计 NP问题-精选文档
算法设计与分析 第九章NP问题
第九章 NP －完全问题§1 关于问题及算法的描述为了应用算法复杂性理论，首先要对问题、问题的一般描述、计算模型、算法、算法的复杂性给出严格的定义。
但在给出精确定义之前，我们先回顾一下有关概念的粗略解释。
所谓一个问题(problem)是指一个有待回答、通常含有几个值还未确定的自由变量的一个一般性提问(question)。
它由两部分决定：一是对其所有参数的一般性描述；二是对该问题的答案所应满足的某些特性的说明。
而一个问题的某个例子则可通过指定问题中所有参数的具体取值来得到。
以下用II 表示某个问题，用I 表示其例子。
例1.1 旅行商问题该问题的参数是由所需访问城市的一个有限集合},,,{11m C C C C =和C 中每对城市j i C C ,之间的距离),(j i C C d 所组成。
它的一个解是对所给城市的一个排序),,,()()2()1(m C C C πππ ，使得该排序极小化下面表达式（目标函数）的值),(),()1()()1(11)(ππππC C d C C d m i m i i ++-=∑旅行商问题的任一个例子的是通过限定城市的数目，并指定每两个城市之间的具体距离而得到的。
例如：{}4321,,,C C C C C =，10),(,10),(,10),(,10),(,10),(,10),(212121212121======C C d C C d C C d C C d C C d C C d 就构成了一个具体例子，而这个例子的一个解是排序4321,,,C C C C ，因为四个城市的这个排序所对应旅行路线是所有能旅行路线中长度最小的，且为27。
所谓算法(algorithm)是指用来求解某一问题的、带有一般性的一步一步的过程。
它是用来描述可在许多计算机上实现任一计算流程的抽象形式，其一般性可以超越任何具体实现时的细节。
注意，复杂性理论中对算法的定义与我们通常理解的具体算法－用某种计算机语言编写的、可在某一特定计算机上实现的计算机程序－不同。
算法设计与分析 NP完全问题
NP 完全问题研究P=NP 的问题有两条基本思路：1．证明NP 类中的某些问题是难解的，从而得到NP ≠P 。
但是要证明这一点几乎同证明P=NP 一样困难。
2．考察NP 类中问题之间的关系，从中找到一些具有特殊性质的、与P 类问题显著不同的问题。
沿着这一路线人们已经证明了在NP 类中存在被称为NP 完全的子类，简称NPC 问题，并由此发展了一套著名的NP 完全理论。
本节简要先介绍NP 完全性理论。
为此，首先给出各语言之间的多项式变换的概念。
定义 1 所谓从一个语言*11∑⊆L 到另一个语言*22∑⊆L 的多项式变换是指满足下面两个条件的函数*2*1:∑→∑f ，(1) 存在计算f 的一个多项式时间DTM 程序；(2) 对于所有的*1∑∈x 有：1L x ∈当且仅当2)(L x f ∈。
用21L L ∝表示存在一个从语言1L 到语言2L 的多项式变换。
相应地，对于判定问题21,∏∏，设e 1和e 2是相应的编码策略。
若],[],[2211e L e L ∏∝∏，则记为21∏∝∏。
也可以从问题的层次来叙述：由判定问题1∏到判定问题2∏的多项式变换是满足下列条件的函数21:∏∏→D D f ，(1) f 可由一个多项式时间的确定性算法来计算；(2) 对于所有的1∏∈I D 有：1∏∈I D 当且仅当2)(∏∈I Y f 。
定义2 称一个语言L （判定问题∏）为NP 完全的（NPC ），如果)(NP NP L ∈∏∈，且对于所有别的语言NP L ∈'（判定问题NP ∈∏'）均有)'('∏∝∏∝L L 。
按照定义2，要证明问题∏是NP 完全的，需要证明所有的NP 问题均能够经多项式变换变成∏。
这几乎是很难做到的。
如果NP 完全问题比较多，我们也不能对每一个这样的问题都这样验证。
为此我们讨论一些NPC 问题的有用的性质。
性质1 如果L L ∝'，则P L ∈意味着P L ∈'。
浙大计算机面试题库及答案
浙大计算机面试题库及答案一、算法与数据结构1. 请简述什么是最短路径算法，并列举几种常见的最短路径算法。
最短路径算法是用来寻找两个节点之间最短路径的一种算法。
常见的最短路径算法包括迪杰斯特拉算法（Dijkstra）、弗洛伊德算法（Floyd-Warshall）、贝尔曼-福特算法（Bellman-Ford）等。
2. 请解释什么是动态规划，并简要介绍动态规划的实现步骤。
动态规划是将一个大问题分解为若干个子问题，并通过保存子问题的解来降低求解复杂度的一种算法思想。
实现步骤包括定义状态、确定状态转移方程、确定初始条件和计算顺序。
二、操作系统1. 什么是进程和线程，它们之间有什么区别？进程是操作系统中资源分配的最小单位，是运行程序的载体，拥有独立的内存空间和执行环境；而线程是进程中的一个执行单元，与其他线程共享进程的资源，拥有独立的执行流程。
区别：- 进程间资源相互独立，线程间资源共享；- 进程拥有独立的地址空间，线程共享进程的地址空间；- 进程间切换开销比较大，线程间切换开销较小。
2. 请解释什么是死锁，并列举避免死锁的方法。
死锁是指系统中的进程或线程因为互相等待对方所持有的资源而无法继续执行的一种状态。
避免死锁的方法包括：资源分级法、资源有序性法、银行家算法、避免环路法等。
三、网络1. 简述HTTP和HTTPS的区别。
HTTP（Hypertext Transfer Protocol）是一种用于传输超文本的应用层协议，明文传输，安全性较低；而HTTPS（Hypertext Transfer Protocol Secure）是基于HTTP协议的一种安全的传输协议，通过SSL/TLS加密数据传输，保证数据的安全性。
2. 请解释什么是TCP/IP协议栈，并介绍TCP和UDP的区别。
TCP/IP协议栈是一组用于互联网中数据通信的网络协议的集合。
它由多层协议构成，包括物理层、数据链路层、网络层、传输层和应用层。
TCP（Transmission Control Protocol）是一种面向连接、可靠传输的协议，提供错误检测和重传机制，适用于对数据可靠性要求较高的场景；而UDP（User Datagram Protocol）是一种无连接、不可靠传输的协议，不提供错误检测和重传机制，适用于对实时性要求较高的场景。
什么是P问题、NP问题和NPC问题PPT课件
2020/10/13
2
先用几句话简单说明一下时间复杂度
数据规模变得有多大，花的时间也跟着变得有多长， 这个程序的时间复杂度就是O(n)，比如找n个数中 的最大值；
而像冒泡排序、插入排序等，数据扩大2倍，时间 变慢4倍的，属于O(n^2)的复杂度。
因此，我们会说，一个O(0.01*n^3)的程序的效率 比O(100*n^2)的效率低，尽管在n很小的时候，前 者优于后者，但后者时间随数据规模增长得慢，最 终O(n^3)的复杂度将远远超过O(n^2)。我们也说， O(n^100)的复杂度小于O(1.01^n)的复杂度。
2020/10/13
4
先用几句话简单说明一下时间复杂度
2020/10/13
8
NP问题
我说，我RP很好，肯定能随便给你指条很短的路出来。然后 我就胡乱画了几条线，说就这条吧。那人按我指的这条把权 值加起来一看，嘿，神了，路径长度98，比100小。于是答 案出来了，存在比100小的路径。
别人会问他这题怎么做出来的，他就可以说，因为我找到了 一个比100 小的解。
2020/10/13
5
不可解问题
自然地，人们会想到一个问题：会不会所有的问题都 可以找到复杂度为多项式级的算法呢？
答案是否定的。有些问题甚至根本不可能找到一个正 确的算法来，这称之为“不可解问 题”(Undecidable Decision Problem)。
例如：
Hamilton回路。
问题是这样的：给你一个图，问你能否找到一条经过每个顶 点一次且恰好一次（不遗漏也不重复）最后又走回来的路 （满足这个条件的路径叫做Hamilton回路）。
浙大版《Python程序设计》题目集（第三章）
浙⼤版《Python程序设计》题⽬集（第三章）height = list(map(int,input().split(" ")))sum = 0for i in height:sum = sum + iavg = sum / len(height)for i in height:if i > avg:print(i,end = " ")num = eval(input())i = 1ls = []count = 0weight = [7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2]M = ['1','0','X','9','8','7','6','5','4','3','2']add_weight = 0error = []while i <= num:str = input()ls.append(str)i = i + 1for k in range(len(ls)):if ls[k][:-1].isdigit():for t in range(len(ls[k]) - 1):add_weight = add_weight + int(ls[k][t])*weight[t]res = add_weight % 11if M[res] == ls[k][-1]:continueelse:error.append(ls[k])else:error.append(ls[k])count = count + 1if count:for m in error:print(m)else:print("All passed")str = input()a,b = input().split(" ")index_list = []char_list = []for i in range(len(str)):if str[i] == a or str[i] == b:char_list.append(str[i])index_list.append(i)list = list(zip(index_list[::-1],char_list[::-1]))for j in range(len(list)):print(list[j][0],list[j][1])look = input()str = input()index = 0flag = Falsefor i in range(len(str)):if str[i] == look:index = iflag = Trueif not flag:print("Not Found")else:print("index = ",index,sep = "")str = input()res = ""for i in range(len(str)):if str[i] <= '9' and str[i] >= '0':res = res + str[i]print(int(res))values = list(map(int,input().split(" ")))num = values[0]dict = {}for i in values[1::]:if i in dict.keys():dict[i] = dict[i] + 1else:dict[i] = 1max_values = max(dict.values())for key,value in dict.items():if value == max_values:print(key,value)num = eval(input())count = 1values = []dict = {}values = list(map(int,input().split(" ")))for i in range(len(values)):if not (values[i] in dict.keys()):dict.update({values[i]:i})max_keys = max(dict.keys())for key,value in dict.items():if key == max_keys:print(key,value)str = input()print(str[::-1])while True:strs = input()if strs[-1] == "#":strs = strs[:-1]breakls = []flag = Falsefor str in strs:if str == "-":flag = Truels.append(str)ls_select = []strs_select = ""for i in ls:if (i <= 'f' and i >= 'a') or (i <= 'F' and i >= 'A') or (i <= '9' and i >= '0'):ls_select.append(i)for t in ls_select:strs_select = strs_select + tif len(strs_select) != 0 and flag == True:print("-",int(strs_select,16),sep = '')else:print(int(strs_select,16))str = input()count = 0for i in str:if i != 'A' and i != 'E' and i != 'I' and i != 'O' and i != 'U' and i <= 'Z' and i >= 'A': count = count + 1print(count)strs = list(input().split(" "))#冒泡排序算法实现import operatorfor i in range(len(strs)):for j in range(i+1,len(strs)):if operator.lt(strs[j],strs[i]):t = strs[j]strs[j] = strs[i]strs[i] = tprint("After sorted:")for str in strs:print(str)num = input()sum = 0len = len(num)for i in num:sum = sum + int(i)print(len,sum,sep = ' ')strs = input()ls = []for str in strs:ls.append(str)for i in range(len(ls)):if ls[i] >= 'A' and ls[i] <='Z':ls[i] = chr(155-ord(ls[i]))for k in ls:print(k,end = '')while True:strs = input()if strs[-1] == "#":strs = strs[:-1]breakls = []for str in strs:ls.append(str)for i in range(len(ls)):if ls[i] >= 'a' and ls[i] <= 'z':ls[i] = ls[i].upper()elif ls[i] >= 'A' and ls[i] <= 'Z':ls[i] = ls[i].lower()for k in ls:print(k,end = '')strs = input()count = 1i = 0while i < len(strs):if strs[i] != ' ':i = i + 1else:if strs[i - 1] != ' ' and i != 0:count = count + 1i = i + 1else:i = i + 1print(count)strs = input()ls = []ls_del = []for str in strs:ls.append(str)for i in range(len(ls)):if ls[i] not in ls_del:ls_del.append(ls[i])ls_sort = sorted(ls_del,reverse = False)for i in ls_sort:print(i,end = '')strs = input().strip()ch = input().strip()ls = []i = 0for str in strs:ls.append(str)length = len(ls)while i < length:if (ord(ls[i]) == ord(ch)) or ((ord(ls[i]) + 32) == ord(ch)) or ((ord(ls[i]) - 32) == ord(ch)): ls.pop(i)length = length - 1else:i = i + 1res = ""for k in ls:res = res + kprint("result:",res)strs = input()ls = []dict = {}count = 0num = 0for str in strs:ls.append(str)for i in ls:if dict:if i <= 'z' and i >= 'a':for j in list(dict.keys()):if ord(i) != ord(j) + 32 and ord(i) != ord(j):num = num + 1if num == len(list(dict.keys())):dict.update({i:"true"})count = count + 1num = 0else:num = 0breakelif i <= 'Z' and i >= 'A':for j in list(dict.keys()):if ord(i) != ord(j) and ord(i) != ord(j) -32:num = num + 1if num == len(list(dict.keys())):dict.update({i:"true"})count = count + 1num = 0else:num = 0breakelse:dict.update({i:"true"})count = count + 1if count < 10:print("not found")else:for key in dict.keys():print(key,end = '')num = eval(input())count = 1ls = []while count <= num:str = input()ls.append(str)count = count + 1max_len = len(ls[0])for i in ls:if len(i) > max_len:max_len = len(i)max = iprint("The longest is",max)strs = input()ls = []i = 0for str in strs:ls.append(str)while i < len(ls):if int(ls[-1]) != 0:for j in ls[::-1]:print(j,end = '')i = len(ls)else:if int(ls[-2]) == 0:print(ls[0])breakelse:print(ls[1],ls[0],sep = '')breakstrs = input()ls = []count = 1for str in strs:ls.append(str)for i in range(len(ls) // 2):if ls[i] == ls[len(ls) - 1 -i]:count = count + 1if count > len(ls) // 2:print("Yes")else:print("No")strs = input()ls = []dict = {}for str in strs:ls.append(str)for i in range(len(ls)):if ls[i] <= 'Z' and ls[i] >= 'A' and i != 0: if not ls[i] in dict.keys():dict.update({ls[i]:"true"})else:continueelif ls[i] <= 'Z' and ls[i] >= 'A' and i == 0: dict.update({ls[i]:"true"})else:continueif not len(dict):print("Not Found")else:for key in dict.keys():print(key,end = '')。
浙大计算机面试题及答案
浙大计算机面试题及答案一、数据结构与算法1. 请解释什么是数据结构，并列举几种常见的数据结构。
数据结构是计算机中对数据的组织、存储和管理的方式。
常见的数据结构包括数组、链表、堆栈、队列、树、图等。
2. 请解释什么是算法，并列举几种常见的算法。
算法是解决问题的一系列步骤或指令。
常见的算法包括排序算法（如冒泡排序、快速排序）、查找算法（如二分查找）、图算法（如最短路径算法）等。
3. 请解释什么是时间复杂度和空间复杂度。
时间复杂度是衡量算法执行时间随输入规模增长而增长的速度。
常用的时间复杂度有O(1)（常数时间复杂度）、O(log n)（对数时间复杂度）、O(n)（线性时间复杂度）、O(n^2)（平方时间复杂度）等。
空间复杂度是衡量算法执行所需内存空间随输入规模增长而增长的速度。
常用的空间复杂度有O(1)（常数空间复杂度）、O(n)（线性空间复杂度）等。
4. 请解释什么是动态规划算法，并给出一个实际的应用场景。
动态规划是将复杂问题分解为子问题，并记录子问题的解，避免重复计算，从而提高算法效率的一种算法思想。
一个实际的应用场景是求解最长公共子序列问题，即找出两个序列中最长的公共子序列。
5. 请解释什么是贪心算法，并给出一个实际的应用场景。
贪心算法是一种每步选择当前最优解的算法思想。
一个实际的应用场景是求解零钱找零问题，即用最少数量的硬币找零。
二、操作系统与网络1. 请解释什么是操作系统，并列举几种常见的操作系统。
操作系统是计算机系统的核心软件，负责管理计算机硬件资源、提供用户接口和运行应用程序等。
常见的操作系统有Windows、Linux、Unix、macOS等。
2. 请解释什么是进程和线程，并解释二者的区别。
进程是程序在操作系统中的一次执行过程，具有独立的地址空间和资源。
线程是进程的一个执行单元，多个线程共享进程的资源。
区别在于进程是独立的执行单位，而线程是进程内的执行单位。
3. 请解释什么是虚拟内存，并解释其作用。
浙江大学-算法设计与分析-图论作业-最短路径算法选择方式
浙江大学-算法设计与分析-图论作业-最短路径算法选择方式介绍本文档旨在介绍最短路径算法的选择方式，以帮助解决浙江大学算法设计与分析课程中的图论作业。
最短路径算法在图论中，最短路径算法用于计算两个顶点之间的最短路径。
常用的最短路径算法包括Dijkstra算法和Bellman-Ford算法。
Dijkstra算法Dijkstra算法是一种贪婪算法，用于计算从一个顶点到其他所有顶点的最短路径。
该算法首先将所有顶点的距离初始化为无穷大，然后逐步更新距离，直到找到最短路径。
Dijkstra算法的时间复杂度为O((V + E)logV)，其中V是顶点数，E是边数。
Bellman-Ford算法Bellman-Ford算法是一种动态规划算法，用于计算从一个顶点到其他所有顶点的最短路径，可以处理带有负权边的图。
该算法通过迭代更新顶点之间的距离，直到找到最短路径。
Bellman-Ford算法的时间复杂度为O(VE)，其中V是顶点数，E是边数。
最短路径算法选择方式在选择最短路径算法时，应考虑以下因素：1. 图的规模：如果图的规模较小，可以选择Dijkstra算法。
其时间复杂度比Bellman-Ford算法低，适用于规模较小的图。
2. 边的权重：如果图的边权重存在负值，则应选择Bellman-Ford算法，因为它可以处理带有负权边的图。
3. 时间效率要求：如果对计算时间有较高要求，可以选择Dijkstra算法。
该算法的时间复杂度较低，计算时间相对较短。
4. 可行解要求：如果需要检测负权回路或获取最短路径的具体路径信息，应选择Bellman-Ford算法。
该算法可以检测负权回路，并返回最短路径的具体路径信息。
综合考虑以上因素，可以根据实际情况选择最适合的最短路径算法。
总结最短路径算法选择的关键因素包括图的规模、边的权重、时间效率要求和可行解要求。
根据这些因素，可以选择Dijkstra算法或Bellman-Ford算法中的一种或多种来解决最短路径问题。
浙江大学Java语言程序设计实验问题详解全集
Java答案全集实验汇总。
实验2 数据类型和变量的使用一、程序填空，在屏幕上显示一个短句“Programming in Java is fun!”import java.io.*;public class Test10001{public static void main(String args[]){/*------------------------*/System.out.println("Programming in Java is fun!");}}二、程序填空，在屏幕上显示如下网格。
+---+---+| | || | |+---+---+import java.io.*;public class Test10002{public static void main(String args[]){/*------------------------*/System.out.println("+---+---+");System.out.println("| | |");System.out.println("| | |");System.out.println("+---+---+");}}三、编写程序，在屏幕上显示如下图案。
（要求：第1行行首无空格，每行行尾无空格）* * * ** * ** **public class Test10003{public static void main(String args[]){/*------------------------*/System.out.println("* * * *");System.out.println(" * * *");System.out.println(" * *");System.out.println(" *");} }实验3 运算符和表达式的使用1、运行结果：m=2 k=1x=1.0 y=2.0 z=-3.0ch1=-A ch2=Ach1=-A ch2=aHello,Welcome to core Java!思考题：(1)字符'A'的Unicode码比字符'a'的Unicode码小32。
浙江大学计算机考研历年面试题集
浙江大学计算机考研 历年面试问题集一、面向对象程序设计1、多态和动态链接的区别多态（Polymorphism）按字面的意思就是“多种形状”。
多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。
简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针动态链接库（Dynamic Link Library，缩写为DLL）是一个可以被其它应用程序共享的程序模块，其中封装了一些可以被共享的例程和资源。
动态链接库文件与可执行文件（exe）非常类似，区别在于DLL中虽然包含了可执行代码却不能单独执行，而应由Windows应用程序直接或间接调用。
动态链接是相对于静态链接而言的。
所谓静态链接是指把要调用的函数或者过程链接到可执行文件中，成为可执行文件的一部分。
换句话说，函数和过程的代码就在程序的exe文件中，该文件包含了运行时所需的全部代码。
当多个程序都调用相同函数时，内存中就会存在这个函数的多个拷贝，这样就浪费了宝贵的内存资源。
而动态链接所调用的函数代码并没有被拷贝到应用程序的可执行文件中去，而是仅仅在其中加入了所调用函数的描述信息（往往是一些重定位信息）。
仅当应用程序被装入内存开始运行时，在Windows的管理下，才在应用程序与相应的DLL之间建立链接关系。
当要执行所调用DLL中的函数时，根据链接产生的重定位信息，Windows才转去执行DLL中相应的函数代码。
2、解释面向对象里面的动态绑定在面向对象语言中，可以从一个类派生出另一个类。
派生出其它类的类称为基类，又称为父类。
被派生的类称为派生类，又称为子类。
派生类可以具有父类的特性，共享父类的成员函数，使用父类的成员，还可以定义自己的新特性，定义自己的数据成员和成员函数。
一个派生类可以从一个基类派生，也可以从多个基类派生。
从一个基类派生的继承称为单继承；从多个基类派生的继承称为多继承。
浙江大学 算法与程序设计 NP问题
Decision problem and language
the set of instances for any decision problem Q is simply the set Σ*, where Σ = {0, 1}. Since Q is entirely characterized by those problem instances that produce a 1 (yes) answer, we can view Q as a language L over Σ = {0, 1}, where L = {x ∈ Σ*: Q(x) = 1}. Example: PATH = {〈G, u, v, k〉 : G = (V, E) is an undirected graph, u, v ∈ V, k ≥ 0 is an integer, and there exists a path from u to v in G consisting of at most k edges}.
4
Certifiers and Certificates: Composite (合数)
COMPOSITES. Given an integer s, is s composite? Certificate. A nontrivial factor t of s. Note that such a certificate exists iff s is composite. Moreover |t| ≤ |s|. Certifier. boolean C(s, t) { if (t ≤1 or t ≥ s) return false else if (s is a multiple of t) return true else return false }
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Optimization problems. in which each feasible (i.e., "legal") solution has an associated value, an solution with the best value.
NP and Computational Intractability
叶德仕 yedeshigmail
1
Decision Problems
Decision problem. (the answer is simply "yes" or "no" )
X is a set of strings. Instance: string s. Algorithm A solves problem X: A(s) = yes iff s ∈ X.
2
Polynomial time. Algorithm A runs in poly-time if for every string s, A(s) terminates in at most p(|s|) "steps", where p(.) is some polynomial. Certification algorithm intuition.
8
P, NP, EXP
P. Decision problems for which there is a poly-time algorithm. EXP. Decision problems for which there is an exponential-time algorithm. NP. Decision problems for which there is a poly-time certifier.
3
Def. Algorithm C(s, t) is a certifier for problem X if for every string s, s ∈ X iff there exists a string t such that C(s, t) = yes. NP. Decision problems for which there exists a poly-time certifier. Remark. NP stands for nondeterministic poly-time.
9
Certifiers and Certificates: Hamiltonian Cycle
HAM-CYCLE. Given an undirected graph G = (V, E), does there exist a simple cycle C that visits every node? Certificate. A permutation of the n nodes. Certifier. Check that the permutation contains each node in V exactly once, and that there is an edge between each pair of adjacent nodes in the permutation. Conclusion. HAM-CYCLE is in NP.
4
Certifiers and Certificates: Composite (合数)
COMPOSITES. Given an integer s, is s composite? Certificate. A nontrivial factor t of s. Note that such a certificate exists iff s is composite. Moreover |t| ≤ |s|. Certifier. boolean C(s, t) { if (t ≤1 or t ≥ s) return false else if (s is a multiple of t) return true else return false }
5
Example
Instance. s = 437,669. Certificate. t = 541 or 809. Conclusion. COMPOSITES is in NP.
6
Certifiers and Certificates: 3-Satisfiability
SAT. Given a CNF formula , is there a satisfying assignment? Certificate. An assignment of truth values to the n boolean variables. Certifier. Check that each clause in has at least one true literal.
Certifier views things from "managerial" viewpoint. Certifier doesn't determine whether s ∈ X on its own; rather, it checks a proposed certificate t that s ∈ X. i.e., certifier verify the proposed solution t and the instance s whether C(s,t) is yes.
Instance:
( x x x ) ( x x x ) ( x x x ) ( x x x ) 1 2 3 1 2 3 1 2 4 1 3 4
Certificate:
x 1 , x 1 , x 0 , x 1 1 2 3 4
7
Conclusion. SAT is in NP.