这是一个古典问题.假设有N个修道士和N个野人准备渡河,但只有一天能容纳C人的小船，为了防止野人吃掉修道士，要求无论在何处（即两岸、船上）,修道士的人数不得少于野人的人数(除非修道士人数为0）。如果两种人都会划船，试设计一个程序，确定他们能否渡过河去，若能,则给出一个小船来回次数最少的最佳方案，并打印出船来回的状态及野人和修道士人数变化状态

这是一个经典的计算机科学问题，被称为"河里的牧师和魔鬼"问题。下面是一个简单的解决方案：

首先，我们需要定义一个状态表示。一个状态包括左岸的修道士人数、野人人数、船的位置，以及右岸的修道士人数和野人人数。

我们可以使用广度优先搜索算法来搜索所有可能的状态，直到找到一种方案，使得所有修道士和野人都能够安全地渡河。在搜索的过程中，我们需要遵守以下规则：

1. 船只能够容纳C个人；
2. 修道士的人数不能少于野人的人数（除非修道士人数为0）；
3. 船只能够被划到左岸或右岸；
4. 每个状态只能够被访问一次，以避免重复搜索。

一旦找到了一种可行的方案，我们可以通过回溯来打印出船来回的状态及野人和修道士人数变化状态。这里是一个简单的Python代码实现：

from collections import deque

N = 3
C = 2

class State:
    def __init__(self, ml, cl, mr, cr, boat):
        self.ml = ml
        self.cl = cl
        self.mr = mr
        self.cr = cr
        self.boat = boat

    def is_valid(self):
        if self.ml < 0 or self.cl < 0 or self.mr < 0 or self.cr < 0:
            return False
        if (self.ml > 0 and self.ml < self.cl) or (self.mr > 0 and self.mr < self.cr):
            return False
        return True

    def is_target(self):
        return self.ml == 0 and self.cl == 0

    def __eq__(self, other):
        return self.ml == other.ml and self.cl == other.cl and self.mr == other.mr and self.cr == other.cr and self.boat == other.boat

    def __hash__(self):
        return hash((self.ml, self.cl, self.mr, self.cr, self.boat))

    def __str__(self):
        return "ML: {}, CL: {}, MR: {}, CR: {}, Boat: {}".format(self.ml, self.cl, self.mr, self.cr, self.boat)

def get_next_states(state):
    states = []
    if state.boat == "left":
        for i in range(C+1):
            for j in range(C+1-i):
                if i+j == 0:
                    continue
                new_state = State(state.ml-i, state.cl-j, state.mr+i, state.cr+j, "right")
                if new_state.is_valid():
                    states.append(new_state)
    else:
        for i in range(C+1):
            for j in range(C+1-i):
                if i+j == 0:
                    continue
                new_state = State(state.ml+i, state.cl+j, state.mr-i, state.cr-j, "left")
                if new_state.is_valid():
                    states.append(new_state)
    return states

def bfs(start_state):
    visited = set()
    queue = deque([(start_state, [])])
    while queue:
        state, path = queue.popleft()
        if state.is_target():
            return path
        for next_state in get_next_states(state):
            if next_state in visited:
                continue
            visited.add(next_state)
            queue.append((next_state, path + [(state, next_state)]))
    return None

start_state = State(N, N, 0, 0, "left")
path = bfs(start_state)
if path:
    for i, (state, next_state) in enumerate(path):
        print("Step {}".format(i+1))
        if state.boat == "left":
            print("{} monks and {} cannibals move from left to right".format(state.ml-next_state.ml, state.cl-next_state.cl))
        else:
            print("{} monks and {} cannibals move from right to left".format(state.mr-next_state.mr, state.cr-next_state.cr))
        print("Left bank: {} monks and {} cannibals".format(next_state.ml, next_state.cl))
        print("Right bank: {} monks and {} cannibals".format(next_state.mr, next_state.cr))
        print("Boat: {}".format(next_state.boat))
        print("")
else:
    print("No solution found")

在这个代码中，我们先定义了一个State类来表示状态。它包括了左岸的修道士人数、野人人数、右岸的修道士人数、野人人数和船的位置。我们还定义了一些方法来判断状态是否合法、是否达到目标状态、以及用于比较和哈希的方法。

然后，我们实现了一个get_next_states方法，用于获取下一个可能的状态。它首先判断船的位置，然后在0到C之间枚举修道士和野人的数量，计算出下一个状态。我们还需要判断下一个状态是否合法。如果合法，就将其添加到返回值中。

接下来，我们实现了一个bfs方法，用于进行广度优先搜索。它使用一个visited集合来避免重复搜索，使用一个queue队列来存储状态和路径。如果找到了目标状态，就返回路径。否则，就继续搜索。

最后，我们使用start_state作为起始状态来调用bfs方法，并将返回的路径打印出来。在每个步骤中，我们打印出船来回的状态及野人和修道士人数变化状态。