source_code: import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.PrintStream;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.List;
  
  /*
   * @author Ivan Pryvalov (ivan.pryvalov@gmail.com)
   */
  public class Codeforces_R136_Div1_A implements Runnable{
  	
  	private void solve() throws IOException {
  		int n = scanner.nextInt();
  		int[] a = new int[n];
  		for (int i = 0; i < a.length; i++) {
  			a[i] = scanner.nextInt();
  		}
  		
  		boolean sorted = true;
  		for (int i = 0; i < a.length; i++) {
  			if (!isOk(a, i)){
  				sorted = false;
  			}
  		}
  		if (sorted){
  			out.println("YES");
  			return;
  		}
  		
  		List<Integer> idx = new ArrayList<Integer>();		
  		for(int i=0; i<n; i++){
  			if (!isOk(a, i)){		
  				idx.add(i);								
  			}
  		}
  		
  		if (idx.size() > 6){
  			out.println("NO");
  			return;
  		}
  		
  		for(int i=0; i<idx.size(); i++){
  			for(int j=0; j<n; j++){
  				swap(a, idx.get(i), j);
  				if (isOk(a, idx) && isOk(a, j)){
  					out.println("YES");
  					return;
  				}
  				swap(a, idx.get(i), j);
  			}
  		}
  		out.println("NO");				
  	}
  
  	private boolean isOk(int[] a, int i) {		
  		boolean ordered = true; 
  		if (i>0 && !(a[i-1] <= a[i])){
  			ordered = false;
  		}
  		if (i<a.length-1 && !(a[i]<=a[i+1])){
  			ordered = false;
  		}
  		return ordered;
  	}
  
  	private boolean isOk(int[] a, List<Integer> idx) {
  		for(int i : idx){
  			if (!isOk(a, i))
  				return false;
  		}
  		return true;
  	}
  
  	private void swap(int[] a, int i, int j) {
  		int tmp = a[i];
  		a[i] = a[j];
  		a[j] = tmp;
  	}
  
  
  	/////////////////////////////////////////////////
  	final int BUF_SIZE = 1024 * 1024 * 8;//important to read long-string tokens properly
  	final int INPUT_BUFFER_SIZE = 1024 * 1024 * 8 ;
  	final int BUF_SIZE_INPUT = 1024;
  	
  	final int BUF_SIZE_OUT = 1024;
  	
  	boolean inputFromFile = false;
  	String filenamePrefix = "A-small-attempt0";
  	String inSuffix = ".in";
  	String outSuffix = ".out";
  	
  	//InputStream bis;
  	//OutputStream bos;
  	PrintStream out;
  	ByteScanner scanner;
  	ByteWriter writer;
  	
  //	@Override
  	public void run() {
  		try{
  			InputStream bis = null;
  			OutputStream bos = null;
  			//PrintStream out = null;
  			if (inputFromFile){
  				File baseFile = new File(getClass().getResource("/").getFile());
  				bis = new BufferedInputStream(
  						new FileInputStream(new File(
  								baseFile, filenamePrefix+inSuffix)),
  								INPUT_BUFFER_SIZE);
  				bos = new BufferedOutputStream(
  						new FileOutputStream(
  								new File(baseFile, filenamePrefix+outSuffix)));
  				out = new PrintStream(bos);
  			}else{
  				bis = new BufferedInputStream(System.in, INPUT_BUFFER_SIZE);
  				bos = new BufferedOutputStream(System.out);
  				out = new PrintStream(bos);
  			}
  			scanner = new ByteScanner(bis, BUF_SIZE_INPUT, BUF_SIZE);
  			writer = new ByteWriter(bos, BUF_SIZE_OUT);
  			
  			solve();
  			out.flush();
  		}catch (Exception e) {
  			e.printStackTrace();
  			System.exit(1);
  		}
  	}
  	
  	public interface Constants{
  		final static byte ZERO = '0';//48 or 0x30
  		final static byte NINE = '9';
  		final static byte SPACEBAR = ' '; //32 or 0x20
  		final static byte MINUS = '-'; //45 or 0x2d	
  		
  		final static char FLOAT_POINT = '.';
  	}
  	
  	public static class EofException extends IOException{
  	}
  	
  	public static class ByteWriter implements Constants {
  		
  		int bufSize = 1024;
  		byte[] byteBuf = new byte[bufSize];
  		OutputStream os;
  		
  		public ByteWriter(OutputStream os, int bufSize){
  			this.os = os;
  			this.bufSize = bufSize;
  		}
  		
  		public void writeInt(int num) throws IOException{
  	         int byteWriteOffset = byteBuf.length;
  	         if (num==0){
  	        	 byteBuf[--byteWriteOffset] = ZERO;
  	         }else{
  	        	 int numAbs = Math.abs(num);
  	        	 while (numAbs>0){
  	        		 byteBuf[--byteWriteOffset] = (byte)((numAbs % 10) + ZERO);
  	        		 numAbs /= 10;
  	        	 }
  	        	 if (num<0)
  	        		 byteBuf[--byteWriteOffset] = MINUS;
  	         }
  	         os.write(byteBuf, byteWriteOffset, byteBuf.length - byteWriteOffset);
  		}
  		
  		/**
  		 * Please ensure ar.length <= byteBuf.length!
  		 * 
  		 * @param ar
  		 * @throws IOException
  		 */
  		public void writeByteAr(byte[] ar) throws IOException{
  			for (int i = 0; i < ar.length; i++) {
  				byteBuf[i] = ar[i];
  			}
  			os.write(byteBuf,0,ar.length);
  		}
  		
  		public void writeSpaceBar() throws IOException{
  			byteBuf[0] = SPACEBAR;
  			os.write(byteBuf,0,1);
  		}
  		
  	}
  	
  	public static class ByteScanner implements Constants{
  		
  		InputStream is;
  		
  		public ByteScanner(InputStream is, int bufSizeInput, int bufSize){
  			this.is = is;
  			this.bufSizeInput = bufSizeInput;
  			this.bufSize = bufSize;
  			
  			byteBufInput = new byte[this.bufSizeInput];
  			byteBuf = new byte[this.bufSize];
  		}
  		
  		public ByteScanner(byte[] data){
  			byteBufInput = data;
  			bufSizeInput = data.length;
  			bufSize = data.length;
  			byteBuf = new byte[bufSize];
  			byteRead = data.length;
  			bytePos = 0;
  		}
  		
  		private int bufSizeInput;
  		private int bufSize;
  		
  		byte[] byteBufInput;
  		byte by=-1;
  		int byteRead=-1;
  		int bytePos=-1;
  
  		byte[] byteBuf;
  		int totalBytes;
  		
  		boolean eofMet = false;
  		
  		private byte nextByte() throws IOException{
  			
  			if (bytePos<0 || bytePos>=byteRead){
  				byteRead = is==null? -1: is.read(byteBufInput);
  				bytePos=0;
  				if (byteRead<0){
  					byteBufInput[bytePos]=-1;//!!!
  					if (eofMet)
  						throw new EofException();
  					eofMet = true;
  				}
  			}
  			return byteBufInput[bytePos++];
  		}
  		
  		/**
  		 * Returns next meaningful character as a byte.<br>
  		 * 
  		 * @return
  		 * @throws IOException
  		 */
  		public byte nextChar() throws IOException{
  			while ((by=nextByte())<=0x20);
  			return by;
  		}
  		
  		/**
  		 * Returns next meaningful character OR space as a byte.<br>
  		 * 
  		 * @return
  		 * @throws IOException
  		 */
  		public byte nextCharOrSpacebar() throws IOException{
  			while ((by=nextByte())<0x20);
  			return by;
  		}
  		
  	    /**
  	     * Reads line.
  	     * 
  	     * @return
  	     * @throws IOException
  	     */
  	    public String nextLine() throws IOException {
              readToken((byte)0x20);
              return new String(byteBuf,0,totalBytes);
  	    }
  	    
  	    public byte[] nextLineAsArray() throws IOException {
              readToken((byte)0x20);
              byte[] out = new byte[totalBytes];
              System.arraycopy(byteBuf, 0, out, 0, totalBytes);
              return out;
  	    }
  	    
  		
  	    /**
  	     * Reads token. Spacebar is separator char.
  	     * 
  	     * @return
  	     * @throws IOException
  	     */
  	    public String nextToken() throws IOException {
              readToken((byte)0x21);
              return new String(byteBuf,0,totalBytes);
  	    }
  	    
  	    /**
  	     * Spacebar is included as separator char
  	     * 
  	     * @throws IOException
  	     */
  	    private void readToken() throws IOException {	    	
              readToken((byte)0x21);
  	    }
  	    
  	    private void readToken(byte acceptFrom) throws IOException {
              totalBytes = 0;
              while ((by=nextByte())<acceptFrom);
              byteBuf[totalBytes++] = by;
              while ((by=nextByte())>=acceptFrom){
                  byteBuf[totalBytes++] = by;
              }
  	    }
  		
  	    public int nextInt() throws IOException{
  			readToken();
  			int num=0, i=0;
  			boolean sign=false;
  			if (byteBuf[i]==MINUS){
  				sign = true;
  				i++;
  			}
  			for (; i<totalBytes; i++){
  				num*=10;
  				num+=byteBuf[i]-ZERO;
  			}
  			return sign?-num:num;
  		}
  		
  		public long nextLong() throws IOException{
  			readToken();
  			long num=0;
  			int i=0;
  			boolean sign=false;
  			if (byteBuf[i]==MINUS){
  				sign = true;
  				i++;
  			}
  			for (; i<totalBytes; i++){
  				num*=10;
  				num+=byteBuf[i]-ZERO;
  			}
  			return sign?-num:num;
  		}
  		
  		/*
  		//TODO test Unix/Windows formats
  		public void toNextLine() throws IOException{
  			while ((ch=nextChar())!='\n');
  		}
  		*/
  		
  		public double nextDouble() throws IOException{
  			readToken();
  			char[] token = new char[totalBytes];
  			for (int i = 0; i < totalBytes; i++) {
  				token[i] = (char)byteBuf[i];
  			}
  			return Double.parseDouble(new String(token));
  		}
  	    
  	}
  	
  	public static void main(String[] args) {
  		new Codeforces_R136_Div1_A().run();
  	}
  	
  }
  